You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cassandra.apache.org by sl...@apache.org on 2014/07/09 18:23:32 UTC
[1/4] git commit: Fix error when doing reverse queries with static
columns
Repository: cassandra
Updated Branches:
refs/heads/trunk 23b022475 -> 304ead14e
Fix error when doing reverse queries with static columns
patch by graham sanderson; reviewed by slebresne for CASSANDRA-7490
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/6893130e
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/6893130e
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/6893130e
Branch: refs/heads/trunk
Commit: 6893130e899f1c9968e49eb58bf8d81212fc3157
Parents: a14211f
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Wed Jul 9 15:50:17 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Wed Jul 9 15:50:17 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 1 +
.../cql3/statements/SelectStatement.java | 17 +-
...QueryFilterWithStaticColumnsPresentTest.java | 357 +++++++++++++++++++
3 files changed, 370 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/6893130e/CHANGES.txt
----------------------------------------------------------------------
diff --git a/CHANGES.txt b/CHANGES.txt
index 23be338..3553e4a 100644
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@ -10,6 +10,7 @@
(CASSANDRA-7455)
* Add inter_dc_stream_throughput_outbound_megabits_per_sec (CASSANDRA-6596)
* Add option to disable STCS in L0 (CASSANDRA-6621)
+ * Fix error when doing reversed queries with static columns (CASSANDRA-7490)
Merged from 1.2:
http://git-wip-us.apache.org/repos/asf/cassandra/blob/6893130e/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
----------------------------------------------------------------------
diff --git a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
index 98bd99a..523302f 100644
--- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
+++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
@@ -472,10 +472,17 @@ public class SelectStatement implements CQLStatement, MeasurableForPreparedCache
if (slice.isAlwaysEmpty(cfDef.cfm.comparator, isReversed))
return staticSlice == null ? null : sliceFilter(staticSlice, limit, toGroup);
- return staticSlice == null
- ? sliceFilter(slice, limit, toGroup)
- : (slice.includes(cfDef.cfm.comparator, staticSlice.finish) ? sliceFilter(new ColumnSlice(staticSlice.start, slice.finish), limit, toGroup)
- : sliceFilter(new ColumnSlice[]{ staticSlice, slice }, limit, toGroup));
+ if (staticSlice == null)
+ return sliceFilter(slice, limit, toGroup);
+
+ if (isReversed)
+ return slice.includes(cfDef.cfm.comparator.reverseComparator, staticSlice.start)
+ ? sliceFilter(new ColumnSlice(slice.start, staticSlice.finish), limit, toGroup)
+ : sliceFilter(new ColumnSlice[]{ slice, staticSlice }, limit, toGroup);
+ else
+ return slice.includes(cfDef.cfm.comparator, staticSlice.finish)
+ ? sliceFilter(new ColumnSlice(staticSlice.start, slice.finish), limit, toGroup)
+ : sliceFilter(new ColumnSlice[]{ staticSlice, slice }, limit, toGroup);
}
List<ColumnSlice> l = new ArrayList<ColumnSlice>(startBounds.size());
@@ -497,7 +504,7 @@ public class SelectStatement implements CQLStatement, MeasurableForPreparedCache
ColumnSlice[] slices;
if (isReversed)
{
- if (l.get(l.size() - 1).includes(cfDef.cfm.comparator, staticSlice.start))
+ if (l.get(l.size() - 1).includes(cfDef.cfm.comparator.reverseComparator, staticSlice.start))
{
slices = l.toArray(new ColumnSlice[l.size()]);
slices[slices.length-1] = new ColumnSlice(slices[slices.length-1].start, ByteBufferUtil.EMPTY_BYTE_BUFFER);
http://git-wip-us.apache.org/repos/asf/cassandra/blob/6893130e/test/unit/org/apache/cassandra/cql3/SliceQueryFilterWithStaticColumnsPresentTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/SliceQueryFilterWithStaticColumnsPresentTest.java b/test/unit/org/apache/cassandra/cql3/SliceQueryFilterWithStaticColumnsPresentTest.java
new file mode 100644
index 0000000..a21ebdc
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/SliceQueryFilterWithStaticColumnsPresentTest.java
@@ -0,0 +1,357 @@
+package org.apache.cassandra.cql3;
+
+import org.apache.cassandra.SchemaLoader;
+import org.apache.cassandra.db.ConsistencyLevel;
+import org.apache.cassandra.db.marshal.*;
+import org.apache.cassandra.exceptions.InvalidRequestException;
+import org.apache.cassandra.exceptions.RequestExecutionException;
+import org.apache.cassandra.exceptions.RequestValidationException;
+import org.apache.cassandra.exceptions.SyntaxException;
+import org.apache.cassandra.gms.Gossiper;
+import org.apache.cassandra.service.ClientState;
+import org.apache.cassandra.service.QueryState;
+import org.apache.cassandra.transport.messages.ResultMessage;
+import org.apache.cassandra.utils.ByteBufferUtil;
+import org.apache.cassandra.utils.MD5Digest;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.nio.ByteBuffer;
+import java.util.*;
+
+import static org.apache.cassandra.cql3.QueryProcessor.process;
+import static org.apache.cassandra.cql3.QueryProcessor.processInternal;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertEquals;
+import static com.google.common.collect.Lists.newArrayList;
+import static org.junit.Assert.fail;
+
+/**
+ * Test column ranges and ordering with static column in table
+ */
+public class SliceQueryFilterWithStaticColumnsPresentTest
+{
+ static ClientState clientState;
+ static String keyspace = "static_column_slice_test";
+
+ @BeforeClass
+ public static void setUpClass() throws Throwable
+ {
+ SchemaLoader.loadSchema();
+ executeSchemaChange("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}");
+ executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.single_clustering (p text, c text, v text, s text static, PRIMARY KEY (p, c));");
+ executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.single_clustering_reversed (p text, c text, v text, s text static, PRIMARY KEY (p, c)) WITH CLUSTERING ORDER BY (c DESC);");
+ execute("INSERT INTO %s.single_clustering (p, c, v, s) values ('p1', 'k1', 'v1', 'sv1')");
+ execute("INSERT INTO %s.single_clustering (p, c, v) values ('p1', 'k2', 'v2')");
+ execute("INSERT INTO %s.single_clustering (p, s) values ('p2', 'sv2')");
+ execute("INSERT INTO %s.single_clustering_reversed (p, c, v, s) values ('p1', 'k1', 'v1', 'sv1')");
+ execute("INSERT INTO %s.single_clustering_reversed (p, c, v) values ('p1', 'k2', 'v2')");
+ execute("INSERT INTO %s.single_clustering_reversed (p, s) values ('p2', 'sv2')");
+ clientState = ClientState.forInternalCalls();
+ }
+
+ @AfterClass
+ public static void stopGossiper()
+ {
+ Gossiper.instance.stop();
+ }
+
+ private static void executeSchemaChange(String query) throws Throwable
+ {
+ try
+ {
+ process(String.format(query, keyspace), ConsistencyLevel.ONE);
+ } catch (RuntimeException exc)
+ {
+ throw exc.getCause();
+ }
+ }
+
+ private static UntypedResultSet execute(String query) throws Throwable
+ {
+ try
+ {
+ return processInternal(String.format(query, keyspace));
+ } catch (RuntimeException exc)
+ {
+ if (exc.getCause() != null)
+ throw exc.getCause();
+ throw exc;
+ }
+ }
+
+ @Test
+ public void testNoClusteringColumnDefaultOrdering() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1'");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p2'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1'");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p2'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+ }
+
+ @Test
+ public void testNoClusteringColumnAscending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p2' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p2' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+ }
+
+ @Test
+ public void testNoClusteringColumnDescending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p2' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p2' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p2", null, "sv2", null);
+ }
+
+ @Test
+ public void testSingleRelationDefaultOrdering() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k1'");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k2'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k3'");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c ='k1'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k1'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k0'");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k1'");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k2'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k3'");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c='k1'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k1'");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k0'");
+ assertEquals(0, results.size());
+ }
+
+ @Test
+ public void testSingleRelationAscending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k1' ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k2' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k3' ORDER BY c ASC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c ='k1' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k1' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k0' ORDER BY c ASC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k1' ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k2' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k3' ORDER BY c ASC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c='k1' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k1' ORDER BY c ASC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k0' ORDER BY c ASC");
+ assertEquals(0, results.size());
+ }
+
+ @Test
+ public void testSingleRelationDescending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k1' ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k2' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c>='k3' ORDER BY c DESC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c ='k1' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k1' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c<='k0' ORDER BY c DESC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k1' ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k2' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c>='k3' ORDER BY c DESC");
+ assertEquals(0, results.size());
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c='k1' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k1' ORDER BY c DESC");
+ assertEquals(1, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c<='k0' ORDER BY c DESC");
+ assertEquals(0, results.size());
+ }
+
+ @Test
+ public void testInDefaultOrdering() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c IN ('k1', 'k2')");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c IN ('k1', 'k2')");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+ }
+
+ @Test
+ public void testInAscending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c IN ('k1', 'k2') ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c IN ('k1', 'k2') ORDER BY c ASC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k1", "sv1", "v1");
+ checkRow(1, results, "p1", "k2", "sv1", "v2");
+ }
+
+ @Test
+ public void testInDescending() throws Throwable
+ {
+ UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE p='p1' AND c IN ('k1', 'k2') ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+
+ results = execute("SELECT * FROM %s.single_clustering_reversed WHERE p='p1' AND c IN ('k1', 'k2') ORDER BY c DESC");
+ assertEquals(2, results.size());
+ checkRow(0, results, "p1", "k2", "sv1", "v2");
+ checkRow(1, results, "p1", "k1", "sv1", "v1");
+ }
+
+ private static void checkRow(int rowIndex, UntypedResultSet results, String... expectedValues)
+ {
+ List<UntypedResultSet.Row> rows = newArrayList(results.iterator());
+ UntypedResultSet.Row row = rows.get(rowIndex);
+ Iterator<ColumnSpecification> columns = row.getColumns().iterator();
+ for (String expected : expectedValues)
+ {
+ String columnName = columns.next().name.toString();
+ String actual = row.has(columnName) ? row.getString(columnName) : null;
+ assertEquals(String.format("Expected value %s for column %s in row %d, but got %s", actual, columnName, rowIndex, expected),
+ expected, actual);
+ }
+ }
+}
[3/4] git commit: Merge branch 'cassandra-2.1.0' into cassandra-2.1
Posted by sl...@apache.org.
Merge branch 'cassandra-2.1.0' into cassandra-2.1
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/89842578
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/89842578
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/89842578
Branch: refs/heads/trunk
Commit: 898425783f9ce0222cf49131e3f8204be0a212fb
Parents: b9d2684 ce46d66
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Wed Jul 9 18:23:02 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Wed Jul 9 18:23:02 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 2 +
.../cql3/statements/SelectStatement.java | 17 +-
.../cassandra/cql3/StaticColumnsQueryTest.java | 263 +++++++++++++++++++
3 files changed, 277 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/89842578/CHANGES.txt
----------------------------------------------------------------------
[4/4] git commit: Merge branch 'cassandra-2.1' into trunk
Posted by sl...@apache.org.
Merge branch 'cassandra-2.1' into trunk
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/304ead14
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/304ead14
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/304ead14
Branch: refs/heads/trunk
Commit: 304ead14ed6822785ffd975722a626fea4a878f8
Parents: 23b0224 8984257
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Wed Jul 9 18:23:26 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Wed Jul 9 18:23:26 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 2 +
.../cql3/statements/SelectStatement.java | 17 +-
.../cassandra/cql3/StaticColumnsQueryTest.java | 263 +++++++++++++++++++
3 files changed, 277 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/304ead14/CHANGES.txt
----------------------------------------------------------------------
[2/4] git commit: Merge branch 'cassandra-2.0' into cassandra-2.1.0
Posted by sl...@apache.org.
Merge branch 'cassandra-2.0' into cassandra-2.1.0
Conflicts:
CHANGES.txt
src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
Project: http://git-wip-us.apache.org/repos/asf/cassandra/repo
Commit: http://git-wip-us.apache.org/repos/asf/cassandra/commit/ce46d661
Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/ce46d661
Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/ce46d661
Branch: refs/heads/trunk
Commit: ce46d6619b05465a89ffaaf8fb3e4c2c1f1e547b
Parents: eb4032e 6893130
Author: Sylvain Lebresne <sy...@datastax.com>
Authored: Wed Jul 9 18:22:04 2014 +0200
Committer: Sylvain Lebresne <sy...@datastax.com>
Committed: Wed Jul 9 18:22:04 2014 +0200
----------------------------------------------------------------------
CHANGES.txt | 2 +
.../cql3/statements/SelectStatement.java | 17 +-
.../cassandra/cql3/StaticColumnsQueryTest.java | 263 +++++++++++++++++++
3 files changed, 277 insertions(+), 5 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/cassandra/blob/ce46d661/CHANGES.txt
----------------------------------------------------------------------
diff --cc CHANGES.txt
index 7fff2d4,3553e4a..e459638
--- a/CHANGES.txt
+++ b/CHANGES.txt
@@@ -1,25 -1,4 +1,27 @@@
-2.0.10
+2.1.0-final
+ * (Windows) fix startup when WMI memory query fails (CASSANDRA-7505)
+ * Anti-compaction proceeds if any part of the repair failed (CASANDRA-7521)
++Merged from 2.0:
++ * Fix error when doing reversed queries with static columns (CASSANDRA-7490)
+
+
+2.1.0-rc3
+ * Consider expiry when reconciling otherwise equal cells (CASSANDRA-7403)
+ * Introduce CQL support for stress tool (CASSANDRA-6146)
+ * Fix ClassCastException processing expired messages (CASSANDRA-7496)
+ * Fix prepared marker for collections inside UDT (CASSANDRA-7472)
+ * Remove left-over populate_io_cache_on_flush and replicate_on_write
+ uses (CASSANDRA-7493)
+ * (Windows) handle spaces in path names (CASSANDRA-7451)
+ * Ensure writes have completed after dropping a table, before recycling
+ commit log segments (CASSANDRA-7437)
+ * Remove left-over rows_per_partition_to_cache (CASSANDRA-7493)
+ * Fix error when CONTAINS is used with a bind marker (CASSANDRA-7502)
+ * Properly reject unknown UDT field (CASSANDRA-7484)
+Merged from 2.0:
+ * Fix CC#collectTimeOrderedData() tombstone optimisations (CASSANDRA-7394)
+ * Support DISTINCT for static columns and fix behaviour when DISTINC is
+ not use (CASSANDRA-7305).
* Workaround JVM NPE on JMX bind failure (CASSANDRA-7254)
* Fix race in FileCacheService RemovalListener (CASSANDRA-7278)
* Fix inconsistent use of consistencyForCommit that allowed LOCAL_QUORUM
http://git-wip-us.apache.org/repos/asf/cassandra/blob/ce46d661/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
----------------------------------------------------------------------
diff --cc src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
index c9572c2,523302f..e4ef0a8
--- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
+++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java
@@@ -460,13 -469,20 +460,20 @@@ public class SelectStatement implement
if (startBounds.size() == 1)
{
ColumnSlice slice = new ColumnSlice(startBounds.get(0), endBounds.get(0));
- if (slice.isAlwaysEmpty(cfDef.cfm.comparator, isReversed))
+ if (slice.isAlwaysEmpty(cfm.comparator, isReversed))
return staticSlice == null ? null : sliceFilter(staticSlice, limit, toGroup);
- return staticSlice == null
- ? sliceFilter(slice, limit, toGroup)
- : (slice.includes(cfm.comparator, staticSlice.finish) ? sliceFilter(new ColumnSlice(staticSlice.start, slice.finish), limit, toGroup)
- : sliceFilter(new ColumnSlice[]{ staticSlice, slice }, limit, toGroup));
+ if (staticSlice == null)
+ return sliceFilter(slice, limit, toGroup);
+
+ if (isReversed)
- return slice.includes(cfDef.cfm.comparator.reverseComparator, staticSlice.start)
++ return slice.includes(cfm.comparator.reverseComparator(), staticSlice.start)
+ ? sliceFilter(new ColumnSlice(slice.start, staticSlice.finish), limit, toGroup)
+ : sliceFilter(new ColumnSlice[]{ slice, staticSlice }, limit, toGroup);
+ else
- return slice.includes(cfDef.cfm.comparator, staticSlice.finish)
++ return slice.includes(cfm.comparator, staticSlice.finish)
+ ? sliceFilter(new ColumnSlice(staticSlice.start, slice.finish), limit, toGroup)
+ : sliceFilter(new ColumnSlice[]{ staticSlice, slice }, limit, toGroup);
}
List<ColumnSlice> l = new ArrayList<ColumnSlice>(startBounds.size());
@@@ -487,10 -504,10 +494,10 @@@
ColumnSlice[] slices;
if (isReversed)
{
- if (l.get(l.size() - 1).includes(cfm.comparator, staticSlice.start))
- if (l.get(l.size() - 1).includes(cfDef.cfm.comparator.reverseComparator, staticSlice.start))
++ if (l.get(l.size() - 1).includes(cfm.comparator.reverseComparator(), staticSlice.start))
{
slices = l.toArray(new ColumnSlice[l.size()]);
- slices[slices.length-1] = new ColumnSlice(slices[slices.length-1].start, ByteBufferUtil.EMPTY_BYTE_BUFFER);
+ slices[slices.length-1] = new ColumnSlice(slices[slices.length-1].start, Composites.EMPTY);
}
else
{
http://git-wip-us.apache.org/repos/asf/cassandra/blob/ce46d661/test/unit/org/apache/cassandra/cql3/StaticColumnsQueryTest.java
----------------------------------------------------------------------
diff --cc test/unit/org/apache/cassandra/cql3/StaticColumnsQueryTest.java
index 0000000,0000000..b386026
new file mode 100644
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/StaticColumnsQueryTest.java
@@@ -1,0 -1,0 +1,263 @@@
++package org.apache.cassandra.cql3;
++
++import org.junit.Test;
++
++/**
++ * Test column ranges and ordering with static column in table
++ */
++public class StaticColumnsQueryTest extends CQLTester
++{
++ @Test
++ public void testSingleClustering() throws Throwable
++ {
++ createTable("CREATE TABLE %s (p text, c text, v text, s text static, PRIMARY KEY (p, c))");
++
++ execute("INSERT INTO %s(p, c, v, s) values (?, ?, ?, ?)", "p1", "k1", "v1", "sv1");
++ execute("INSERT INTO %s(p, c, v) values (?, ?, ?)", "p1", "k2", "v2");
++ execute("INSERT INTO %s(p, s) values (?, ?)", "p2", "sv2");
++
++ assertRows(execute("SELECT * FROM %s WHERE p=?", "p1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=?", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // Ascending order
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // Descending order
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // No order with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c =?", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k0"));
++
++ // Ascending with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c =? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k0"));
++
++ // Descending with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c =? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k0"));
++
++ // IN
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?)", "p1", "k1", "k2"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c ASC", "p1", "k1", "k2"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c DESC", "p1", "k1", "k2"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++ }
++
++ @Test
++ public void testSingleClusteringReversed() throws Throwable
++ {
++ createTable("CREATE TABLE %s (p text, c text, v text, s text static, PRIMARY KEY (p, c)) WITH CLUSTERING ORDER BY (c DESC)");
++
++ execute("INSERT INTO %s(p, c, v, s) values (?, ?, ?, ?)", "p1", "k1", "v1", "sv1");
++ execute("INSERT INTO %s(p, c, v) values (?, ?, ?)", "p1", "k2", "v2");
++ execute("INSERT INTO %s(p, s) values (?, ?)", "p2", "sv2");
++
++ assertRows(execute("SELECT * FROM %s WHERE p=?", "p1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=?", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // Ascending order
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // Descending order
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p2"),
++ row("p2", null, "sv2", null)
++ );
++
++ // No order with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c=?", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k0"));
++
++ // Ascending with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c=? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k0"));
++
++ // Descending with one relation
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k2"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k3"));
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c=? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k1"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k0"));
++
++ // IN
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?)", "p1", "k1", "k2"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c ASC", "p1", "k1", "k2"),
++ row("p1", "k1", "sv1", "v1"),
++ row("p1", "k2", "sv1", "v2")
++ );
++
++ assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c DESC", "p1", "k1", "k2"),
++ row("p1", "k2", "sv1", "v2"),
++ row("p1", "k1", "sv1", "v1")
++ );
++ }
++}