From 084d93daf6b6031909fc318e57a2a205ad32c237 Mon Sep 17 00:00:00 2001 From: Tyler Hobbs Date: Wed, 19 Nov 2014 11:25:09 -0600 Subject: [PATCH] Fix multicolumn relation + COMPACT STORAGE issues Patch by Tyler Hobbs; reviewed by Benjamin Lerer for CASSANDRA-8264 --- CHANGES.txt | 2 + .../cql3/statements/SelectStatement.java | 95 +- .../cql3/MultiColumnRelationTest.java | 1244 +++++++++-------- 3 files changed, 730 insertions(+), 611 deletions(-) diff --git a/CHANGES.txt b/CHANGES.txt index fff6d3a61a..01ea887235 100644 --- a/CHANGES.txt +++ b/CHANGES.txt @@ -1,4 +1,6 @@ 2.0.12: + * Fix some failing queries that use multi-column relations + on COMPACT STORAGE tables (CASSANDRA-8264) * Fix InvalidRequestException with ORDER BY (CASSANDRA-8286) * Disable SSLv3 for POODLE (CASSANDRA-8265) * Fix millisecond timestamps in Tracing (CASSANDRA-8297) diff --git a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java index f1d1aab97e..db25716216 100644 --- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java @@ -713,9 +713,9 @@ public class SelectStatement implements CQLStatement, MeasurableForPreparedCache CFDefinition.Name name = idIter.next(); assert r != null && !r.isSlice(); - List values = r.values(variables); - if (values.size() == 1) + if (r.isEQ()) { + List values = r.values(variables); ByteBuffer val = values.get(0); if (val == null) throw new InvalidRequestException(String.format("Invalid null value for clustering key part %s", name.name)); @@ -723,26 +723,56 @@ public class SelectStatement implements CQLStatement, MeasurableForPreparedCache } else { - // We have a IN, which we only support for the last column. - // If compact, just add all values and we're done. Otherwise, - // for each value of the IN, creates all the columns corresponding to the selection. - if (values.isEmpty()) - return null; - SortedSet columns = new TreeSet(cfDef.cfm.comparator); - Iterator iter = values.iterator(); - while (iter.hasNext()) + if (!r.isMultiColumn()) { - ByteBuffer val = iter.next(); - ColumnNameBuilder b = iter.hasNext() ? builder.copy() : builder; - if (val == null) - throw new InvalidRequestException(String.format("Invalid null value for clustering key part %s", name.name)); - b.add(val); - if (cfDef.isCompact) - columns.add(b.build()); - else - columns.addAll(addSelectedColumns(b)); + // We have a IN, which we only support for the last column. + // If compact, just add all values and we're done. Otherwise, + // for each value of the IN, creates all the columns corresponding to the selection. + List values = r.values(variables); + if (values.isEmpty()) + return null; + SortedSet columns = new TreeSet(cfDef.cfm.comparator); + Iterator iter = values.iterator(); + while (iter.hasNext()) + { + ByteBuffer val = iter.next(); + ColumnNameBuilder b = iter.hasNext() ? builder.copy() : builder; + if (val == null) + throw new InvalidRequestException(String.format("Invalid null value for clustering key part %s", name.name)); + b.add(val); + if (cfDef.isCompact) + columns.add(b.build()); + else + columns.addAll(addSelectedColumns(b)); + } + return columns; + } + else + { + // we have a multi-column IN restriction + List> values = ((MultiColumnRestriction.IN) r).splitValues(variables); + if (values.isEmpty()) + return null; + TreeSet inValues = new TreeSet<>(cfDef.cfm.comparator); + for (List components : values) + { + ColumnNameBuilder b = builder.copy(); + for (int i = 0; i < components.size(); i++) + { + if (components.get(i) == null) + { + List clusteringCols = new ArrayList<>(cfDef.clusteringColumns()); + throw new InvalidRequestException("Invalid null value in condition for clustering column " + clusteringCols.get(i + name.position)); + } + b.add(components.get(i)); + } + if (cfDef.isCompact) + inValues.add(b.build()); + else + inValues.addAll(addSelectedColumns(b)); + } + return inValues; } - return columns; } } @@ -1127,10 +1157,27 @@ public class SelectStatement implements CQLStatement, MeasurableForPreparedCache { Comparator comp = cfDef.cfm.comparator; // For dynamic CF, the column could be out of the requested bounds, filter here - if (!sliceRestriction.isInclusive(Bound.START) && comp.compare(c.name(), sliceRestriction.bound(Bound.START, variables)) == 0) - continue; - if (!sliceRestriction.isInclusive(Bound.END) && comp.compare(c.name(), sliceRestriction.bound(Bound.END, variables)) == 0) - continue; + + if (!sliceRestriction.isInclusive(Bound.START)) + { + // even though it's a multi-column restriction, we know it can only contain a bound for one + // column because we've already checked that the comparator is not composite + ByteBuffer bounds = sliceRestriction.isMultiColumn() + ? ((MultiColumnRestriction.Slice) sliceRestriction).componentBounds(Bound.START, variables).get(0) + : sliceRestriction.bound(Bound.START, variables); + if (comp.compare(c.name(), bounds) == 0) + continue; + } + + if (!sliceRestriction.isInclusive(Bound.END)) + { + // see the above comment on using the first bound from the multi-column restriction + ByteBuffer bounds = sliceRestriction.isMultiColumn() + ? ((MultiColumnRestriction.Slice) sliceRestriction).componentBounds(Bound.END, variables).get(0) + : sliceRestriction.bound(Bound.END, variables); + if (comp.compare(c.name(), bounds) == 0) + continue; + } } result.newRow(); diff --git a/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java b/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java index 498d3327a4..ea4f1a6045 100644 --- a/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java +++ b/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java @@ -57,11 +57,25 @@ public class MultiColumnRelationTest { SchemaLoader.loadSchema(); executeSchemaChange("CREATE KEYSPACE IF NOT EXISTS %s WITH replication = {'class': 'SimpleStrategy', 'replication_factor': '1'}"); - executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.single_partition (a int PRIMARY KEY, b int)"); - executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.compound_partition (a int, b int, c int, PRIMARY KEY ((a, b)))"); - executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.single_clustering (a int, b int, c int, PRIMARY KEY (a, b))"); - executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.multiple_clustering (a int, b int, c int, d int, PRIMARY KEY (a, b, c, d))"); - executeSchemaChange("CREATE TABLE IF NOT EXISTS %s.multiple_clustering_reversed (a int, b int, c int, d int, PRIMARY KEY (a, b, c, d)) WITH CLUSTERING ORDER BY (b DESC, c ASC, d DESC)"); + for (boolean isCompact : new boolean[]{false, true}) + { + String tableSuffix = isCompact ? "_compact" : ""; + String compactOption = isCompact ? " WITH COMPACT STORAGE" : ""; + + executeSchemaChange( + "CREATE TABLE IF NOT EXISTS %s.single_partition" + tableSuffix + "(a int PRIMARY KEY, b int)" + compactOption); + executeSchemaChange( + "CREATE TABLE IF NOT EXISTS %s.compound_partition" +tableSuffix + "(a int, b int, c int, PRIMARY KEY ((a, b)))" + compactOption); + executeSchemaChange( + "CREATE TABLE IF NOT EXISTS %s.single_clustering" + tableSuffix + "(a int, b int, c int, PRIMARY KEY (a, b))" + compactOption); + executeSchemaChange( + "CREATE TABLE IF NOT EXISTS %s.multiple_clustering" + tableSuffix + "(a int, b int, c int, d int, PRIMARY KEY (a, b, c, d))" + compactOption); + + compactOption = isCompact ? " COMPACT STORAGE AND " : ""; + executeSchemaChange( + "CREATE TABLE IF NOT EXISTS %s.multiple_clustering_reversed" + tableSuffix + + "(a int, b int, c int, d int, PRIMARY KEY (a, b, c, d)) WITH " + compactOption + " CLUSTERING ORDER BY (b DESC, c ASC, d DESC)"); + } clientState = ClientState.forInternalCalls(); } @@ -207,40 +221,46 @@ public class MultiColumnRelationTest @Test public void testSingleClusteringColumnEquality() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 2, 0)"); - UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) = (1)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + "(a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 2, 0)"); + UntypedResultSet results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) = (1)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0); - results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) = (3)"); - assertEquals(0, results.size()); + results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) = (3)"); + assertEquals(0, results.size()); + } } @Test public void testMultipleClusteringColumnEquality() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 2, 0, 0)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) = (1)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(2, results, 0, 1, 1, 1); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 2, 0, 0)"); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) = (1)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(2, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) = (1, 1)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0); - checkRow(1, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) = (1, 1)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 1, 0); + checkRow(1, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) = (1, 1, 1)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1); - execute("DELETE FROM %s.multiple_clustering WHERE a=0 AND b=2 and c=0 and d=0"); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) = (1, 1, 1)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 1, 1); + execute("DELETE FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND b=2 and c=0 and d=0"); + } } @Test(expected=InvalidRequestException.class) @@ -270,372 +290,392 @@ public class MultiColumnRelationTest @Test public void testMixSingleAndTupleInequalities() throws Throwable { - String[] queries = new String[]{ - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 0) AND b < 1", - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 0) AND c < 1", - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND b > 1 AND (b, c, d) < (1, 1, 0)", - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND c > 1 AND (b, c, d) < (1, 1, 0)", - }; - - for (String query : queries) + for (String tableSuffix : new String[]{"", "_compact"}) { - try + String[] queries = new String[]{ + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 0) AND b < 1", + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 0) AND c < 1", + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND b > 1 AND (b, c, d) < (1, 1, 0)", + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND c > 1 AND (b, c, d) < (1, 1, 0)", + }; + + for (String query : queries) { - execute(query); - fail(String.format("Expected query \"%s\" to throw an InvalidRequestException", query)); + try + { + execute(query); + fail(String.format("Expected query \"%s\" to throw an InvalidRequestException", query)); + } + catch (InvalidRequestException e) + { + } } - catch (InvalidRequestException e) {} } } @Test public void testSingleClusteringColumnInequality() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 2, 0)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 2, 0)"); - UntypedResultSet results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > (0)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + UntypedResultSet results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > (0)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) >= (1)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) >= (1)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) < (2)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) < (2)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) <= (1)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) <= (1)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = execute("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > (0) AND (b) < (2)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0); + results = execute("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > (0) AND (b) < (2)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0); + } } @Test public void testMultipleClusteringColumnInequality() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 1)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > (0)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(2, results, 0, 1, 1, 1); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > (0)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(2, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) >= (0)"); - assertEquals(6, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); - checkRow(3, results, 0, 1, 0, 0); - checkRow(4, results, 0, 1, 1, 0); - checkRow(5, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) >= (0)"); + assertEquals(6, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); + checkRow(3, results, 0, 1, 0, 0); + checkRow(4, results, 0, 1, 1, 0); + checkRow(5, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) > (1, 0)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0); - checkRow(1, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) > (1, 0)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 1, 0); + checkRow(1, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) >= (1, 0)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(2, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) >= (1, 0)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(2, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (1, 1, 0)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (1, 1, 0)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) >= (1, 1, 0)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0); - checkRow(1, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) >= (1, 1, 0)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 1, 0); + checkRow(1, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) < (1)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) < (1)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) <= (1)"); - assertEquals(6, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); - checkRow(3, results, 0, 1, 0, 0); - checkRow(4, results, 0, 1, 1, 0); - checkRow(5, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) <= (1)"); + assertEquals(6, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); + checkRow(3, results, 0, 1, 0, 0); + checkRow(4, results, 0, 1, 1, 0); + checkRow(5, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) < (0, 1)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) < (0, 1)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) <= (0, 1)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) <= (0, 1)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) < (0, 1, 1)"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) < (0, 1, 1)"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) <= (0, 1, 1)"); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) <= (0, 1, 1)"); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 0) AND (b) < (1)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 0) AND (b) < (1)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c) < (1, 1)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c) < (1, 1)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c, d) < (1, 1, 0)"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c, d) < (1, 1, 0)"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - // reversed - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > (0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(3, results.size()); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + // reversed + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > (0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(3, results.size()); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) >= (0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(6, results.size()); - checkRow(5, results, 0, 0, 0, 0); - checkRow(4, results, 0, 0, 1, 0); - checkRow(3, results, 0, 0, 1, 1); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) >= (0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(6, results.size()); + checkRow(5, results, 0, 0, 0, 0); + checkRow(4, results, 0, 0, 1, 0); + checkRow(3, results, 0, 0, 1, 1); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) > (1, 0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(2, results.size()); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) > (1, 0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(2, results.size()); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) >= (1, 0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(3, results.size()); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) >= (1, 0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(3, results.size()); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) >= (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(2, results.size()); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) >= (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(2, results.size()); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) < (1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(3, results.size()); - checkRow(2, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) < (1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(3, results.size()); + checkRow(2, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) <= (1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(6, results.size()); - checkRow(5, results, 0, 0, 0, 0); - checkRow(4, results, 0, 0, 1, 0); - checkRow(3, results, 0, 0, 1, 1); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) <= (1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(6, results.size()); + checkRow(5, results, 0, 0, 0, 0); + checkRow(4, results, 0, 0, 1, 0); + checkRow(3, results, 0, 0, 1, 1); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) < (0, 1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) < (0, 1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) <= (0, 1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(3, results.size()); - checkRow(2, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) <= (0, 1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(3, results.size()); + checkRow(2, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) < (0, 1, 1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(2, results.size()); - checkRow(1, results, 0, 0, 0, 0); - checkRow(0, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) < (0, 1, 1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(2, results.size()); + checkRow(1, results, 0, 0, 0, 0); + checkRow(0, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) <= (0, 1, 1) ORDER BY b DESC, c DESC, d DESC"); - checkRow(2, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) <= (0, 1, 1) ORDER BY b DESC, c DESC, d DESC"); + checkRow(2, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 0) AND (b) < (1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 0) AND (b) < (1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c) < (1, 1) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c) < (1, 1) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c, d) < (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (0, 1, 1) AND (b, c, d) < (1, 1, 0) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); + } } @Test public void testMultipleClusteringColumnInequalityReversedComponents() throws Throwable { - // b and d are reversed in the clustering order - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 1, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 1, 1, 0)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + // b and d are reversed in the clustering order + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b) > (0)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 1); - checkRow(2, results, 0, 1, 1, 0); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b) > (0)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 1); + checkRow(2, results, 0, 1, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b) >= (0)"); - assertEquals(6, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 1); - checkRow(2, results, 0, 1, 1, 0); - checkRow(3, results, 0, 0, 0, 0); - checkRow(4, results, 0, 0, 1, 1); - checkRow(5, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b) >= (0)"); + assertEquals(6, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 1); + checkRow(2, results, 0, 1, 1, 0); + checkRow(3, results, 0, 0, 0, 0); + checkRow(4, results, 0, 0, 1, 1); + checkRow(5, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b) < (1)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 1); - checkRow(2, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b) < (1)"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 1); + checkRow(2, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b) <= (1)"); - assertEquals(6, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 1); - checkRow(2, results, 0, 1, 1, 0); - checkRow(3, results, 0, 0, 0, 0); - checkRow(4, results, 0, 0, 1, 1); - checkRow(5, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b) <= (1)"); + assertEquals(6, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 1); + checkRow(2, results, 0, 1, 1, 0); + checkRow(3, results, 0, 0, 0, 0); + checkRow(4, results, 0, 0, 1, 1); + checkRow(5, results, 0, 0, 1, 0); - // preserve pre-6875 behavior (even though the query result is technically incorrect) - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c) > (1, 0)"); - assertEquals(0, results.size()); + // preserve pre-6875 behavior (even though the query result is technically incorrect) + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c) > (1, 0)"); + assertEquals(0, results.size()); + } } @Test public void testLiteralIn() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - // same query, but reversed order for the IN values - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + // same query, but reversed order for the IN values + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b, c) IN ((0, 1))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b, c) IN ((0, 1))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b) IN ((0))"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b) IN ((0))"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) IN ((0, 1)) ORDER BY b DESC, c DESC, d DESC"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1); - checkRow(1, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) IN ((0, 1)) ORDER BY b DESC, c DESC, d DESC"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 1); + checkRow(1, results, 0, 0, 1, 0); + } } @Test public void testLiteralInReversed() throws Throwable { - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering_reversed (a, b, c, d) VALUES (0, -1, 0, 0)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering_reversed" + tableSuffix + " (a, b, c, d) VALUES (0, -1, 0, 0)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1); - checkRow(1, results, 0, 0, 1, 0); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 1); + checkRow(1, results, 0, 0, 1, 0); - // same query, but reversed order for the IN values - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1); - checkRow(1, results, 0, 0, 1, 0); + // same query, but reversed order for the IN values + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 1); + checkRow(1, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((1, 0, 0), (0, 0, 0), (0, 1, 1), (0, 1, 0), (-1, 0, 0))"); - assertEquals(5, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 0, 0, 0); - checkRow(2, results, 0, 0, 1, 1); - checkRow(3, results, 0, 0, 1, 0); - checkRow(4, results, 0, -1, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((1, 0, 0), (0, 0, 0), (0, 1, 1), (0, 1, 0), (-1, 0, 0))"); + assertEquals(5, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 0, 0, 0); + checkRow(2, results, 0, 0, 1, 1); + checkRow(3, results, 0, 0, 1, 0); + checkRow(4, results, 0, -1, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((0, 0, 0))"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 0, 0))"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((0, 1, 1))"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 1))"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 AND (b, c, d) IN ((0, 1, 0))"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((0, 1, 0))"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 and (b, c) IN ((0, 1))"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1); - checkRow(1, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 and (b, c) IN ((0, 1))"); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 1); + checkRow(1, results, 0, 0, 1, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 and (b, c) IN ((0, 0))"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 and (b, c) IN ((0, 0))"); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0, 0); - results = execute("SELECT * FROM %s.multiple_clustering_reversed WHERE a=0 and (b) IN ((0))"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 1); - checkRow(2, results, 0, 0, 1, 0); + results = execute("SELECT * FROM %s.multiple_clustering_reversed" + tableSuffix + " WHERE a=0 and (b) IN ((0))"); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 1); + checkRow(2, results, 0, 0, 1, 0); + } } @Test(expected=InvalidRequestException.class) @@ -664,44 +704,47 @@ public class MultiColumnRelationTest @Test public void testPartitionAndClusteringInClauses() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (1, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (1, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (1, 0, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (1, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (1, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (1, 0, 1, 1)"); - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering WHERE a IN (0, 1) AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); - assertEquals(4, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); - checkRow(2, results, 1, 0, 1, 0); - checkRow(3, results, 1, 0, 1, 1); + UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a IN (0, 1) AND (b, c, d) IN ((0, 1, 0), (0, 1, 1))"); + assertEquals(4, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); + checkRow(2, results, 1, 0, 1, 0); + checkRow(3, results, 1, 0, 1, 1); - // same query, but reversed order for the IN values - results = execute("SELECT * FROM %s.multiple_clustering WHERE a IN (1, 0) AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); - assertEquals(4, results.size()); - checkRow(0, results, 1, 0, 1, 0); - checkRow(1, results, 1, 0, 1, 1); - checkRow(2, results, 0, 0, 1, 0); - checkRow(3, results, 0, 0, 1, 1); + // same query, but reversed order for the IN values + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a IN (1, 0) AND (b, c, d) IN ((0, 1, 1), (0, 1, 0))"); + assertEquals(4, results.size()); + checkRow(0, results, 1, 0, 1, 0); + checkRow(1, results, 1, 0, 1, 1); + checkRow(2, results, 0, 0, 1, 0); + checkRow(3, results, 0, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a IN (0, 1) and (b, c) IN ((0, 1))"); - assertEquals(4, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); - checkRow(2, results, 1, 0, 1, 0); - checkRow(3, results, 1, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a IN (0, 1) and (b, c) IN ((0, 1))"); + assertEquals(4, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); + checkRow(2, results, 1, 0, 1, 0); + checkRow(3, results, 1, 0, 1, 1); - results = execute("SELECT * FROM %s.multiple_clustering WHERE a IN (0, 1) and (b) IN ((0))"); - assertEquals(6, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); - checkRow(3, results, 1, 0, 0, 0); - checkRow(4, results, 1, 0, 1, 0); - checkRow(5, results, 1, 0, 1, 1); + results = execute("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a IN (0, 1) and (b) IN ((0))"); + assertEquals(6, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); + checkRow(3, results, 1, 0, 0, 0); + checkRow(4, results, 1, 0, 1, 0); + checkRow(5, results, 1, 0, 1, 1); + } } // prepare statement tests @@ -777,335 +820,362 @@ public class MultiColumnRelationTest @Test public void testPreparedClusteringColumnEquality() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - MD5Digest id = prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) = (?)"); - UntypedResultSet results = executePrepared(id, makeIntOptions(0)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + MD5Digest id = prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) = (?)"); + UntypedResultSet results = executePrepared(id, makeIntOptions(0)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0); + } } @Test public void testPreparedClusteringColumnEqualitySingleMarker() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - MD5Digest id = prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) = ?"); - UntypedResultSet results = executePrepared(id, options(tuple(0))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 0); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + MD5Digest id = prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) = ?"); + UntypedResultSet results = executePrepared(id, options(tuple(0))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 0); + } } @Test public void testPreparedSingleClusteringColumnInequality() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 2, 0)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 2, 0)"); - MD5Digest id = prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > (?)"); - UntypedResultSet results = executePrepared(id, makeIntOptions(0)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + MD5Digest id = prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > (?)"); + UntypedResultSet results = executePrepared(id, makeIntOptions(0)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) >= (?)"), makeIntOptions(1)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) >= (?)"), makeIntOptions(1)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) < (?)"), makeIntOptions(2)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) < (?)"), makeIntOptions(2)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) <= (?)"), makeIntOptions(1)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) <= (?)"), makeIntOptions(1)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > (?) AND (b) < (?)"), makeIntOptions(0, 2)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > (?) AND (b) < (?)"), makeIntOptions(0, 2)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0); + } } @Test public void testPreparedSingleClusteringColumnInequalitySingleMarker() throws Throwable { - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 0, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 1, 0)"); - execute("INSERT INTO %s.single_clustering (a, b, c) VALUES (0, 2, 0)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 0, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 1, 0)"); + execute("INSERT INTO %s.single_clustering" + tableSuffix + " (a, b, c) VALUES (0, 2, 0)"); - MD5Digest id = prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > ?"); - UntypedResultSet results = executePrepared(id, options(tuple(0))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + MD5Digest id = prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > ?"); + UntypedResultSet results = executePrepared(id, options(tuple(0))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) >= ?"), options(tuple(1))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 0); - checkRow(1, results, 0, 2, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) >= ?"), options(tuple(1))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 0); + checkRow(1, results, 0, 2, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) < ?"), options(tuple(2))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) < ?"), options(tuple(2))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) <= ?"), options(tuple(1))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 0); - checkRow(1, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) <= ?"), options(tuple(1))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 0); + checkRow(1, results, 0, 1, 0); - results = executePrepared(prepare("SELECT * FROM %s.single_clustering WHERE a=0 AND (b) > ? AND (b) < ?"), - options(tuple(0), tuple(2))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0); + results = executePrepared(prepare("SELECT * FROM %s.single_clustering" + tableSuffix + " WHERE a=0 AND (b) > ? AND (b) < ?"), + options(tuple(0), tuple(2))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0); + } } @Test public void testPrepareMultipleClusteringColumnInequality() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 1)"); - UntypedResultSet results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > (?)"), makeIntOptions(0)); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(2, results, 0, 1, 1, 1); + UntypedResultSet results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > (?)"), makeIntOptions(0)); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(2, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) > (?, ?)"), makeIntOptions(1, 0)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0); - checkRow(1, results, 0, 1, 1, 1); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) > (?, ?)"), makeIntOptions(1, 0)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 1, 0); + checkRow(1, results, 0, 1, 1, 1); - results = executePrepared(prepare - ("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (?, ?, ?)"), makeIntOptions(1, 1, 0)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1); + results = executePrepared(prepare + ("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (?, ?, ?)"), makeIntOptions(1, 1, 0)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b) < (?)"), - makeIntOptions(0, 1, 0, 1)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b) < (?)"), + makeIntOptions(0, 1, 0, 1)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 1); - results = executePrepared(prepare - ("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c) < (?, ?)"), - makeIntOptions(0, 1, 1, 1, 1)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare + ("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c) < (?, ?)"), + makeIntOptions(0, 1, 1, 1, 1)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c, d) < (?, ?, ?)"), - makeIntOptions(0, 1, 1, 1, 1, 0)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c, d) < (?, ?, ?)"), + makeIntOptions(0, 1, 1, 1, 1, 0)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - // reversed - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > (?) ORDER BY b DESC, c DESC, d DESC"), - makeIntOptions(0)); - assertEquals(3, results.size()); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + // reversed + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > (?) ORDER BY b DESC, c DESC, d DESC"), + makeIntOptions(0)); + assertEquals(3, results.size()); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c) < (?, ?) ORDER BY b DESC, c DESC, d DESC"), - makeIntOptions(0, 1, 1, 1, 1)); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > (?, ?, ?) AND (b, c) < (?, ?) ORDER BY b DESC, c DESC, d DESC"), + makeIntOptions(0, 1, 1, 1, 1)); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); + } } @Test public void testPrepareMultipleClusteringColumnInequalitySingleMarker() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 1, 1, 1)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 1, 1, 1)"); - UntypedResultSet results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > ?"), options(tuple(0))); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(2, results, 0, 1, 1, 1); + UntypedResultSet results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > ?"), options(tuple(0))); + assertEquals(3, results.size()); + checkRow(0, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(2, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c) > ?"), options(tuple(1, 0))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0); - checkRow(1, results, 0, 1, 1, 1); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c) > ?"), options(tuple(1, 0))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 1, 1, 0); + checkRow(1, results, 0, 1, 1, 1); - results = executePrepared(prepare - ("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > ?"), options(tuple(1, 1, 0))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1); + results = executePrepared(prepare + ("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > ?"), options(tuple(1, 1, 0))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > ? AND (b) < ?"), - options(tuple(0, 1, 0), tuple(1))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > ? AND (b) < ?"), + options(tuple(0, 1, 0), tuple(1))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 0, 1, 1); - results = executePrepared(prepare - ("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > ? AND (b, c) < ?"), - options(tuple(0, 1, 1), tuple(1, 1))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare + ("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > ? AND (b, c) < ?"), + options(tuple(0, 1, 1), tuple(1, 1))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > ? AND (b, c, d) < ?"), - options(tuple(0, 1, 1), tuple(1, 1, 0))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > ? AND (b, c, d) < ?"), + options(tuple(0, 1, 1), tuple(1, 1, 0))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); - // reversed - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b) > ? ORDER BY b DESC, c DESC, d DESC"), - options(tuple(0))); - assertEquals(3, results.size()); - checkRow(2, results, 0, 1, 0, 0); - checkRow(1, results, 0, 1, 1, 0); - checkRow(0, results, 0, 1, 1, 1); + // reversed + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b) > ? ORDER BY b DESC, c DESC, d DESC"), + options(tuple(0))); + assertEquals(3, results.size()); + checkRow(2, results, 0, 1, 0, 0); + checkRow(1, results, 0, 1, 1, 0); + checkRow(0, results, 0, 1, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) > ? AND (b, c) < ? ORDER BY b DESC, c DESC, d DESC"), - options(tuple(0, 1, 1), tuple(1, 1))); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 0, 0); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) > ? AND (b, c) < ? ORDER BY b DESC, c DESC, d DESC"), + options(tuple(0, 1, 1), tuple(1, 1))); + assertEquals(1, results.size()); + checkRow(0, results, 0, 1, 0, 0); + } } @Test public void testPrepareLiteralIn() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - UntypedResultSet results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))"), - makeIntOptions(0, 1, 0, 0, 1, 1)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + UntypedResultSet results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))"), + makeIntOptions(0, 1, 0, 0, 1, 1)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - // same query, but reversed order for the IN values - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))"), - makeIntOptions(0, 1, 1, 0, 1, 0)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + // same query, but reversed order for the IN values + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))"), + makeIntOptions(0, 1, 1, 0, 1, 0)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b, c) IN ((?, ?))"), - makeIntOptions(0, 1)); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b, c) IN ((?, ?))"), + makeIntOptions(0, 1)); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b) IN ((?))"), - makeIntOptions(0)); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b) IN ((?))"), + makeIntOptions(0)); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); + } } @Test public void testPrepareInOneMarkerPerTuple() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - UntypedResultSet results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN (?, ?)"), - options(tuple(0, 1, 0), tuple(0, 1, 1))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + UntypedResultSet results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN (?, ?)"), + options(tuple(0, 1, 0), tuple(0, 1, 1))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - // same query, but reversed order for the IN values - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN (?, ?)"), - options(tuple(0, 1, 1), tuple(0, 1, 0))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + // same query, but reversed order for the IN values + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN (?, ?)"), + options(tuple(0, 1, 1), tuple(0, 1, 0))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b, c) IN (?)"), - options(tuple(0, 1))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b, c) IN (?)"), + options(tuple(0, 1))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b) IN (?)"), - options(tuple(0))); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b) IN (?)"), + options(tuple(0))); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); + } } @Test public void testPrepareInOneMarker() throws Throwable { - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 0)"); - execute("INSERT INTO %s.multiple_clustering (a, b, c, d) VALUES (0, 0, 1, 1)"); + for (String tableSuffix : new String[]{"", "_compact"}) + { + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 0, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 0)"); + execute("INSERT INTO %s.multiple_clustering" + tableSuffix + " (a, b, c, d) VALUES (0, 0, 1, 1)"); - UntypedResultSet results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ?"), - options(list(tuple(0, 1, 0), tuple(0, 1, 1)))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + UntypedResultSet results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ?"), + options(list(tuple(0, 1, 0), tuple(0, 1, 1)))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - // same query, but reversed order for the IN values - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ?"), - options(list(tuple(0, 1, 1), tuple(0, 1, 0)))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + // same query, but reversed order for the IN values + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ?"), + options(list(tuple(0, 1, 1), tuple(0, 1, 0)))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare( - "SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ?"), - options(list())); - assertTrue(results.isEmpty()); + results = executePrepared(prepare( + "SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 AND (b, c, d) IN ?"), + options(list())); + assertTrue(results.isEmpty()); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b, c) IN ?"), - options(list(tuple(0, 1)))); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 0); - checkRow(1, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b, c) IN ?"), + options(list(tuple(0, 1)))); + assertEquals(2, results.size()); + checkRow(0, results, 0, 0, 1, 0); + checkRow(1, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b) IN ?"), - options(list(tuple(0)))); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 0, 0); - checkRow(1, results, 0, 0, 1, 0); - checkRow(2, results, 0, 0, 1, 1); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b) IN ?"), + options(list(tuple(0)))); + assertEquals(3, results.size()); + checkRow(0, results, 0, 0, 0, 0); + checkRow(1, results, 0, 0, 1, 0); + checkRow(2, results, 0, 0, 1, 1); - results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 and (b) IN ?"), - options(list())); - assertTrue(results.isEmpty()); + results = executePrepared(prepare("SELECT * FROM %s.multiple_clustering" + tableSuffix + " WHERE a=0 and (b) IN ?"), + options(list())); + assertTrue(results.isEmpty()); + } } @Test(expected=InvalidRequestException.class)