Merge branch 'cassandra-2.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/07ffe1b1 Tree: http://git-wip-us.apache.org/repos/asf/cassandra/tree/07ffe1b1 Diff: http://git-wip-us.apache.org/repos/asf/cassandra/diff/07ffe1b1 Branch: refs/heads/trunk Commit: 07ffe1b12eb68cd51fdfc8715ffa7df14381df3a Parents: ad91d41 9649594 Author: Tyler Hobbs <tylerho...@apache.org> Authored: Tue Feb 10 15:09:39 2015 -0600 Committer: Tyler Hobbs <tylerho...@apache.org> Committed: Tue Feb 10 15:09:39 2015 -0600 ---------------------------------------------------------------------- CHANGES.txt | 3 + .../cql3/statements/SelectStatement.java | 58 ++++++------ .../cassandra/cql3/MultiColumnRelationTest.java | 94 ++++++++++++++++++++ .../cql3/SingleColumnRelationTest.java | 40 +++++++++ 4 files changed, 170 insertions(+), 25 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/cassandra/blob/07ffe1b1/CHANGES.txt ---------------------------------------------------------------------- diff --cc CHANGES.txt index 92ee5d1,861730f..2113349 --- a/CHANGES.txt +++ b/CHANGES.txt @@@ -1,96 -1,6 +1,99 @@@ -2.0.13: +2.1.4 + * Write partition size estimates into a system table (CASSANDRA-7688) + * cqlsh: Fix keys() and full() collection indexes in DESCRIBE output + (CASSANDRA-8154) ++Merged from 2.0: + * Fix some multi-column relations with indexes on some clustering + columns (CASSANDRA-8275) + + +2.1.3 + * Upgrade libthrift to 0.9.2 (CASSANDRA-8685) + * Don't use the shared ref in sstableloader (CASSANDRA-8704) + * Purge internal prepared statements if related tables or + keyspaces are dropped (CASSANDRA-8693) + * (cqlsh) Handle unicode BOM at start of files (CASSANDRA-8638) + * Stop compactions before exiting offline tools (CASSANDRA-8623) + * Update tools/stress/README.txt to match current behaviour (CASSANDRA-7933) + * Fix schema from Thrift conversion with empty metadata (CASSANDRA-8695) + * Safer Resource Management (CASSANDRA-7705) + * Make sure we compact highly overlapping cold sstables with + STCS (CASSANDRA-8635) + * rpc_interface and listen_interface generate NPE on startup when specified + interface doesn't exist (CASSANDRA-8677) + * Fix ArrayIndexOutOfBoundsException in nodetool cfhistograms (CASSANDRA-8514) + * Switch from yammer metrics for nodetool cf/proxy histograms (CASSANDRA-8662) + * Make sure we don't add tmplink files to the compaction + strategy (CASSANDRA-8580) + * (cqlsh) Handle maps with blob keys (CASSANDRA-8372) + * (cqlsh) Handle DynamicCompositeType schemas correctly (CASSANDRA-8563) + * Duplicate rows returned when in clause has repeated values (CASSANDRA-6706) + * Add tooling to detect hot partitions (CASSANDRA-7974) + * Fix cassandra-stress user-mode truncation of partition generation (CASSANDRA-8608) + * Only stream from unrepaired sstables during inc repair (CASSANDRA-8267) + * Don't allow starting multiple inc repairs on the same sstables (CASSANDRA-8316) + * Invalidate prepared BATCH statements when related tables + or keyspaces are dropped (CASSANDRA-8652) + * Fix missing results in secondary index queries on collections + with ALLOW FILTERING (CASSANDRA-8421) + * Expose EstimatedHistogram metrics for range slices (CASSANDRA-8627) + * (cqlsh) Escape clqshrc passwords properly (CASSANDRA-8618) + * Fix NPE when passing wrong argument in ALTER TABLE statement (CASSANDRA-8355) + * Pig: Refactor and deprecate CqlStorage (CASSANDRA-8599) + * Don't reuse the same cleanup strategy for all sstables (CASSANDRA-8537) + * Fix case-sensitivity of index name on CREATE and DROP INDEX + statements (CASSANDRA-8365) + * Better detection/logging for corruption in compressed sstables (CASSANDRA-8192) + * Use the correct repairedAt value when closing writer (CASSANDRA-8570) + * (cqlsh) Handle a schema mismatch being detected on startup (CASSANDRA-8512) + * Properly calculate expected write size during compaction (CASSANDRA-8532) + * Invalidate affected prepared statements when a table's columns + are altered (CASSANDRA-7910) + * Stress - user defined writes should populate sequentally (CASSANDRA-8524) + * Fix regression in SSTableRewriter causing some rows to become unreadable + during compaction (CASSANDRA-8429) + * Run major compactions for repaired/unrepaired in parallel (CASSANDRA-8510) + * (cqlsh) Fix compression options in DESCRIBE TABLE output when compression + is disabled (CASSANDRA-8288) + * (cqlsh) Fix DESCRIBE output after keyspaces are altered (CASSANDRA-7623) + * Make sure we set lastCompactedKey correctly (CASSANDRA-8463) + * (cqlsh) Fix output of CONSISTENCY command (CASSANDRA-8507) + * (cqlsh) Fixed the handling of LIST statements (CASSANDRA-8370) + * Make sstablescrub check leveled manifest again (CASSANDRA-8432) + * Check first/last keys in sstable when giving out positions (CASSANDRA-8458) + * Disable mmap on Windows (CASSANDRA-6993) + * Add missing ConsistencyLevels to cassandra-stress (CASSANDRA-8253) + * Add auth support to cassandra-stress (CASSANDRA-7985) + * Fix ArrayIndexOutOfBoundsException when generating error message + for some CQL syntax errors (CASSANDRA-8455) + * Scale memtable slab allocation logarithmically (CASSANDRA-7882) + * cassandra-stress simultaneous inserts over same seed (CASSANDRA-7964) + * Reduce cassandra-stress sampling memory requirements (CASSANDRA-7926) + * Ensure memtable flush cannot expire commit log entries from its future (CASSANDRA-8383) + * Make read "defrag" async to reclaim memtables (CASSANDRA-8459) + * Remove tmplink files for offline compactions (CASSANDRA-8321) + * Reduce maxHintsInProgress (CASSANDRA-8415) + * BTree updates may call provided update function twice (CASSANDRA-8018) + * Release sstable references after anticompaction (CASSANDRA-8386) + * Handle abort() in SSTableRewriter properly (CASSANDRA-8320) + * Fix high size calculations for prepared statements (CASSANDRA-8231) + * Centralize shared executors (CASSANDRA-8055) + * Fix filtering for CONTAINS (KEY) relations on frozen collection + clustering columns when the query is restricted to a single + partition (CASSANDRA-8203) + * Do more aggressive entire-sstable TTL expiry checks (CASSANDRA-8243) + * Add more log info if readMeter is null (CASSANDRA-8238) + * add check of the system wall clock time at startup (CASSANDRA-8305) + * Support for frozen collections (CASSANDRA-7859) + * Fix overflow on histogram computation (CASSANDRA-8028) + * Have paxos reuse the timestamp generation of normal queries (CASSANDRA-7801) + * Fix incremental repair not remove parent session on remote (CASSANDRA-8291) + * Improve JBOD disk utilization (CASSANDRA-7386) + * Log failed host when preparing incremental repair (CASSANDRA-8228) + * Force config client mode in CQLSSTableWriter (CASSANDRA-8281) + * Fix sstableupgrade throws exception (CASSANDRA-8688) + * Fix hang when repairing empty keyspace (CASSANDRA-8694) +Merged from 2.0: * Fix IllegalArgumentException in dynamic snitch (CASSANDRA-8448) * Add support for UPDATE ... IF EXISTS (CASSANDRA-8610) * Fix reversal of list prepends (CASSANDRA-8733) http://git-wip-us.apache.org/repos/asf/cassandra/blob/07ffe1b1/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java ---------------------------------------------------------------------- diff --cc src/java/org/apache/cassandra/cql3/statements/SelectStatement.java index 633d43c,2fa57b9..08777c7 --- a/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java +++ b/src/java/org/apache/cassandra/cql3/statements/SelectStatement.java @@@ -85,10 -80,12 +85,12 @@@ public class SelectStatement implement private final Restriction[] columnRestrictions; /** Restrictions on non-primary key columns (i.e. secondary index restrictions) */ - private final Map<CFDefinition.Name, Restriction> metadataRestrictions = new HashMap<CFDefinition.Name, Restriction>(); + private final Map<ColumnIdentifier, Restriction> metadataRestrictions = new HashMap<ColumnIdentifier, Restriction>(); - // All restricted columns not covered by the key or index filter - private final Set<ColumnDefinition> restrictedColumns = new HashSet<ColumnDefinition>(); + // The map keys are the name of the columns that must be converted into IndexExpressions if a secondary index need + // to be used. The value specify if the column has an index that can be used to for the relation in which the column + // is specified. - private final Map<CFDefinition.Name, Boolean> restrictedNames = new HashMap<CFDefinition.Name, Boolean>(); ++ private final Map<ColumnDefinition, Boolean> restrictedColumns = new HashMap<ColumnDefinition, Boolean>(); private Restriction.Slice sliceRestriction; private boolean isReversed; @@@ -1059,23 -1028,23 +1061,23 @@@ return Collections.emptyList(); List<IndexExpression> expressions = new ArrayList<IndexExpression>(); - for (ColumnDefinition def : restrictedColumns) - for (CFDefinition.Name name : restrictedNames.keySet()) ++ for (ColumnDefinition def : restrictedColumns.keySet()) { Restriction restriction; - switch (name.kind) + switch (def.kind) { - case KEY_ALIAS: - restriction = keyRestrictions[name.position]; + case PARTITION_KEY: + restriction = keyRestrictions[def.position()]; break; - case COLUMN_ALIAS: - restriction = columnRestrictions[name.position]; + case CLUSTERING_COLUMN: + restriction = columnRestrictions[def.position()]; break; - case COLUMN_METADATA: + case REGULAR: case STATIC: - restriction = metadataRestrictions.get(name); + restriction = metadataRestrictions.get(def.name); break; default: - // We don't allow restricting a VALUE_ALIAS for now in prepare. + // We don't allow restricting a COMPACT_VALUE for now in prepare. throw new AssertionError(); } @@@ -1097,39 -1067,27 +1099,49 @@@ } } } + else if (restriction.isContains()) + { + SingleColumnRestriction.Contains contains = (SingleColumnRestriction.Contains)restriction; + for (ByteBuffer value : contains.values(options)) + { + validateIndexedValue(def, value); + expressions.add(new IndexExpression(def.name.bytes, Operator.CONTAINS, value)); + } + for (ByteBuffer key : contains.keys(options)) + { + validateIndexedValue(def, key); + expressions.add(new IndexExpression(def.name.bytes, Operator.CONTAINS_KEY, key)); + } + } else { - List<ByteBuffer> values = restriction.values(options); + ByteBuffer value; + if (restriction.isMultiColumn()) + { - List<ByteBuffer> values = restriction.values(variables); - value = values.get(name.position); ++ List<ByteBuffer> values = restriction.values(options); ++ value = values.get(def.position()); + } + else + { - List<ByteBuffer> values = restriction.values(variables); ++ List<ByteBuffer> values = restriction.values(options); + if (values.size() != 1) + throw new InvalidRequestException("IN restrictions are not supported on indexed columns"); - if (values.size() != 1) - throw new InvalidRequestException("IN restrictions are not supported on indexed columns"); + value = values.get(0); + } - ByteBuffer value = validateIndexedValue(def, values.get(0)); - validateIndexExpressionValue(value, name); - expressions.add(new IndexExpression(name.name.key, IndexOperator.EQ, value)); ++ validateIndexedValue(def, value); + expressions.add(new IndexExpression(def.name.bytes, Operator.EQ, value)); } } + + if (usesSecondaryIndexing) + { + ColumnFamilyStore cfs = Keyspace.open(keyspace()).getColumnFamilyStore(columnFamily()); + SecondaryIndexManager secondaryIndexManager = cfs.indexManager; + secondaryIndexManager.validateIndexSearchersForQuery(expressions); + } + return expressions; } @@@ -1503,7 -1506,7 +1515,7 @@@ // All (or none) of the partition key columns have been specified; // hence there is no need to turn these restrictions into index expressions. if (!stmt.usesSecondaryIndexing) - stmt.restrictedColumns.removeAll(cfm.partitionKeyColumns()); - stmt.restrictedNames.keySet().removeAll(cfDef.partitionKeys()); ++ stmt.restrictedColumns.keySet().removeAll(cfm.partitionKeyColumns()); if (stmt.selectsOnlyStaticColumns && stmt.hasClusteringColumnsRestriction()) throw new InvalidRequestException("Cannot restrict clustering columns when selecting only static columns"); @@@ -1514,21 -1517,16 +1526,15 @@@ if (stmt.isKeyRange && hasQueriableClusteringColumnIndex) stmt.usesSecondaryIndexing = true; - if (!stmt.usesSecondaryIndexing) - // The clustering columns that can be used to perform a slice filtering on the secondary index do not - // need to be converted into IndexExpressions. Therefore, if they are not indexed by an index that support - // the relation in which they have been specified, we can removes them from the restrictedNames map. - for (Name clusteringColumn : cfDef.clusteringColumns()) ++ for (ColumnDefinition def : cfm.clusteringColumns()) { - for (ColumnDefinition def : cfm.clusteringColumns()) - { - // Remove clustering column restrictions that can be handled by slices; the remainder will be - // handled by filters (which may require a secondary index). - Restriction restriction = stmt.columnRestrictions[def.position()]; - if (restriction != null) - { - if (restriction.canEvaluateWithSlices()) - stmt.restrictedColumns.remove(def); - else - stmt.usesSecondaryIndexing = true; - } - } - Boolean indexed = stmt.restrictedNames.get(clusteringColumn); ++ // Remove clustering column restrictions that can be handled by slices; the remainder will be ++ // handled by filters (which may require a secondary index). ++ Boolean indexed = stmt.restrictedColumns.get(def); + if (indexed == null) + break; - if (!indexed) - stmt.restrictedNames.remove(clusteringColumn); ++ if (!indexed && stmt.columnRestrictions[def.position()].canEvaluateWithSlices()) ++ stmt.restrictedColumns.remove(def); } // Even if usesSecondaryIndexing is false at this point, we'll still have to use one if @@@ -1551,21 -1553,18 +1557,23 @@@ } /** Returns a pair of (hasQueriableIndex, hasQueriableClusteringColumnIndex) */ - private boolean[] processRelationEntity(SelectStatement stmt, Relation relation, ColumnIdentifier entity, CFDefinition cfDef) throws InvalidRequestException + private boolean[] processRelationEntity(SelectStatement stmt, + SecondaryIndexManager indexManager, + Relation relation, + ColumnIdentifier entity, + ColumnDefinition def) throws InvalidRequestException { - CFDefinition.Name name = cfDef.get(entity); - if (name == null) + if (def == null) handleUnrecognizedEntity(entity, relation); - stmt.restrictedColumns.add(def); - - if (cfDef.cfm.getColumnDefinition(name.name.key).isIndexed() && relation.operator() == Relation.Type.EQ) + SecondaryIndex index = indexManager.getIndexForColumn(def.name.bytes); + if (index != null && index.supportsOperator(relation.operator())) + { - stmt.restrictedNames.put(name, Boolean.TRUE); - return new boolean[]{true, name.kind == CFDefinition.Name.Kind.COLUMN_ALIAS}; ++ stmt.restrictedColumns.put(def, Boolean.TRUE); + return new boolean[]{true, def.kind == ColumnDefinition.Kind.CLUSTERING_COLUMN}; + } - stmt.restrictedNames.put(name, Boolean.FALSE); + ++ stmt.restrictedColumns.put(def, Boolean.FALSE); return new boolean[]{false, false}; } @@@ -2134,38 -2126,7 +2142,38 @@@ } } - private SingleColumnRelation findInclusiveClusteringRelationForCompact(CFDefinition cfDef) + /** + * Checks if the specified statement will need to filter the data. + * + * @param stmt the statement to test. + * @return <code>true</code> if the specified statement will need to filter the data, <code>false</code> + * otherwise. + */ + private static boolean needFiltering(SelectStatement stmt) + { + return stmt.restrictedColumns.size() > 1 + || (stmt.restrictedColumns.isEmpty() && !stmt.columnFilterIsIdentity()) + || (!stmt.restrictedColumns.isEmpty() - && stmt.isRestrictedByMultipleContains(Iterables.getOnlyElement(stmt.restrictedColumns))); ++ && stmt.isRestrictedByMultipleContains(Iterables.getOnlyElement(stmt.restrictedColumns.keySet()))); + } + + private int indexOf(ColumnDefinition def, Selection selection) + { + return indexOf(def, selection.getColumns().iterator()); + } + + private int indexOf(final ColumnDefinition def, Iterator<ColumnDefinition> defs) + { + return Iterators.indexOf(defs, new Predicate<ColumnDefinition>() + { + public boolean apply(ColumnDefinition n) + { + return def.name.equals(n.name); + } + }); + } + + private SingleColumnRelation findInclusiveClusteringRelationForCompact(CFMetaData cfm) { for (Relation r : whereClause) { http://git-wip-us.apache.org/repos/asf/cassandra/blob/07ffe1b1/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java ---------------------------------------------------------------------- diff --cc test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java index 4c3ba2a,30a9226..25df030 --- a/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java +++ b/test/unit/org/apache/cassandra/cql3/MultiColumnRelationTest.java @@@ -469,90 -1140,233 +469,184 @@@ public class MultiColumnRelationTest ex } @Test - public void testPrepareInOneMarker() throws Throwable + public void testMultipleClusteringReversedComponents() throws Throwable { - for (String tableSuffix : new String[]{"", "_compact"}) + for (String compactOption : new String[]{"", " COMPACT STORAGE AND"}) { - 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)"); + createTable("CREATE TABLE %s (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)"); - 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); + // b and d are reversed in the clustering order + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, 0, 0); + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, 1, 1); + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, 1, 0); + + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, 0, 0); + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, 1, 1); + execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, 1, 0); + + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b) > (?)", 0, 0), + row(0, 1, 0, 0), + row(0, 1, 1, 1), + row(0, 1, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b) >= (?)", 0, 0), + row(0, 1, 0, 0), + row(0, 1, 1, 1), + row(0, 1, 1, 0), + row(0, 0, 0, 0), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b) < (?)", 0, 1), + row(0, 0, 0, 0), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b) <= (?)", 0, 1), + row(0, 1, 0, 0), + row(0, 1, 1, 1), + row(0, 1, 1, 0), + row(0, 0, 0, 0), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a=? AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))", 0, 1, 1, 1, 0, 1, 1), + row(0, 1, 1, 1), + row(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" + tableSuffix + " 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) 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) 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())); - assertTrue(results.isEmpty()); + assertRows(execute("SELECT * FROM %s WHERE a=? AND (b, c, d) IN ((?, ?, ?), (?, ?, ?))", 0, 0, 1, 1, 1, 1, 1), + row(0, 1, 1, 1), + row(0, 0, 1, 1) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b, c, d) IN (?, ?, ?, ?, ?, ?)", + 0, tuple(1, 0, 0), tuple(1, 1, 1), tuple(1, 1, 0), tuple(0, 0, 0), tuple(0, 1, 1), tuple(0, 1, 0)), + row(0, 1, 0, 0), + row(0, 1, 1, 1), + row(0, 1, 1, 0), + row(0, 0, 0, 0), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b, c) IN (?)", 0, tuple(0, 1)), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b, c) IN (?)", 0, tuple(0, 0)), + row(0, 0, 0, 0) + ); + + assertRows(execute("SELECT * FROM %s WHERE a = ? AND (b) IN ((?))", 0, 0), + row(0, 0, 0, 0), + row(0, 0, 1, 1), + row(0, 0, 1, 0) + ); + + // preserve pre-6875 behavior (even though the query result is technically incorrect) + assertEmpty(execute("SELECT * FROM %s WHERE a = ? AND (b, c) > (?, ?)", 0, 1, 0)); } } + + @Test + public void testMultipleClusteringWithIndex() throws Throwable + { - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 0, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 0, 1, 0, 1)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 0, 1, 1, 2)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 1, 0, 0, 0)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 1, 1, 0, 1)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 1, 1, 1, 2)"); - execute("INSERT INTO %s.multiple_clustering_with_indices (a, b, c, d, e) VALUES (0, 2, 0, 0, 0)"); - - UntypedResultSet results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b) = (1)"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 1, 0, 0, 0); - checkRow(1, results, 0, 1, 1, 0, 1); - checkRow(2, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b, c) = (1, 1) ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 1, 1, 0, 1); - checkRow(1, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b, c) = (1, 1) AND e = 2 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b) IN ((1)) AND e = 2 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b) IN ((0), (1)) AND e = 2 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 2); - checkRow(1, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b, c) IN ((0, 1)) AND e = 2 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b, c) IN ((0, 1), (1, 1)) AND e = 2 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 2); - checkRow(1, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b) >= (1) AND e = 2 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1, 2); - - results = execute("SELECT * FROM %s.multiple_clustering_with_indices WHERE (b, c) >= (1, 1) AND e = 2 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 1, 1, 1, 2); ++ createTable("CREATE TABLE %s (a int, b int, c int, d int, e int, PRIMARY KEY (a, b, c, d))"); ++ createIndex("CREATE INDEX ON %s (b)"); ++ createIndex("CREATE INDEX ON %s (e)"); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 0, 0, 0, 0); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 0, 1, 0, 1); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 0, 1, 1, 2); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 1, 0, 0, 0); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 1, 1, 0, 1); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 1, 1, 1, 2); ++ execute("INSERT INTO %s (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)", 0, 2, 0, 0, 0); ++ assertRows(execute("SELECT * FROM %s WHERE (b) = (?)", 1), ++ row(0, 1, 0, 0, 0), ++ row(0, 1, 1, 0, 1), ++ row(0, 1, 1, 1, 2)); ++ assertRows(execute("SELECT * FROM %s WHERE (b, c) = (?, ?) ALLOW FILTERING", 1, 1), ++ row(0, 1, 1, 0, 1), ++ row(0, 1, 1, 1, 2)); ++ assertRows(execute("SELECT * FROM %s WHERE (b, c) = (?, ?) AND e = ? ALLOW FILTERING", 1, 1, 2), ++ row(0, 1, 1, 1, 2)); ++ assertRows(execute("SELECT * FROM %s WHERE (b) IN ((?)) AND e = ?", 1, 2), ++ row(0, 1, 1, 1, 2)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE (b) IN ((?), (?)) AND e = ?", 0, 1, 2), ++ row(0, 0, 1, 1, 2), ++ row(0, 1, 1, 1, 2)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE (b, c) IN ((?, ?)) AND e = ?", 0, 1, 2), ++ row(0, 0, 1, 1, 2)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE (b, c) IN ((?, ?), (?, ?)) AND e = ?", 0, 1, 1, 1, 2), ++ row(0, 0, 1, 1, 2), ++ row(0, 1, 1, 1, 2)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE (b) >= (?) AND e = ?", 1, 2), ++ row(0, 1, 1, 1, 2)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE (b, c) >= (?, ?) AND e = ?", 1, 1, 2), ++ row(0, 1, 1, 1, 2)); + } + + @Test - public void testPartitionWithIndex() throws Throwable ++ public void testMultiplePartitionKeyAndMultiClusteringWithIndex() throws Throwable + { - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 0, 0, 0)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 1, 0, 1)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 1, 1, 2)"); - - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 0, 0, 3)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 1, 0, 4)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 1, 1, 5)"); - - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 2, 0, 0, 5)"); - - UntypedResultSet results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c) = (1) ALLOW FILTERING"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 1, 0, 0, 3); - checkRow(1, results, 0, 0, 1, 1, 0, 4); - checkRow(2, results, 0, 0, 1, 1, 1, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c, d) = (1, 1) ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 0, 4); - checkRow(1, results, 0, 0, 1, 1, 1, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c) IN ((1)) AND f = 5 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c) IN ((1), (2)) AND f = 5 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - checkRow(1, results, 0, 0, 2, 0, 0, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c, d) IN ((1, 0)) AND f = 3 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 0, 0, 3); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c) >= (1) AND f = 5 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - checkRow(1, results, 0, 0, 2, 0, 0, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c, d) >= (1, 1) AND f = 5 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - checkRow(1, results, 0, 0, 2, 0, 0, 5); - } ++ createTable("CREATE TABLE %s (a int, b int, c int, d int, e int, f int, PRIMARY KEY ((a, b), c, d, e))"); ++ createIndex("CREATE INDEX ON %s (c)"); ++ createIndex("CREATE INDEX ON %s (f)"); + - @Test(expected=InvalidRequestException.class) - public void testMissingPartitionComponentWithInRestrictionOnIndexedColumn() throws Throwable - { - execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c, d) IN ((1, 1)) ALLOW FILTERING"); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 0, 0, 0); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 1, 0, 1); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 1, 1, 2); + - @Test(expected=InvalidRequestException.class) - public void testMissingPartitionComponentWithSliceRestrictionOnIndexedColumn() throws Throwable - { - execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND (c, d) >= (1, 1) ALLOW FILTERING"); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 0, 0, 3); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 1, 0, 4); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 1, 1, 5); + - @Test(expected=InvalidRequestException.class) - public void testPrepareLiteralInWithShortTuple() throws Throwable - { - prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((?, ?))"); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 2, 0, 0, 5); + - @Test(expected=InvalidRequestException.class) - public void testPrepareLiteralInWithLongTuple() throws Throwable - { - prepare("SELECT * FROM %s.multiple_clustering WHERE a=0 AND (b, c, d) IN ((?, ?, ?, ?, ?))"); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c) = (?) ALLOW FILTERING", 0, 1), ++ row(0, 0, 1, 0, 0, 3), ++ row(0, 0, 1, 1, 0, 4), ++ row(0, 0, 1, 1, 1, 5)); + - @Test(expected=InvalidRequestException.class) - public void testPrepareLiteralInWithPartitionKey() throws Throwable - { - prepare("SELECT * FROM %s.multiple_clustering WHERE (a, b, c, d) IN ((?, ?, ?, ?))"); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c, d) = (?, ?) ALLOW FILTERING", 0, 1, 1), ++ row(0, 0, 1, 1, 0, 4), ++ row(0, 0, 1, 1, 1, 5)); + - @Test(expected=InvalidRequestException.class) - public void testPrepareLiteralInSkipsClusteringColumn() throws Throwable - { - prepare("SELECT * FROM %s.multiple_clustering WHERE (c, d) IN ((?, ?))"); - } ++ assertInvalidMessage("Partition key part b must be restricted since preceding part is", ++ "SELECT * FROM %s WHERE a = ? AND (c, d) IN ((?, ?)) ALLOW FILTERING", 0, 1, 1); + - private static QueryOptions makeIntOptions(Integer... values) - { - List<ByteBuffer> buffers = new ArrayList<>(values.length); - for (int value : values) - buffers.add(ByteBufferUtil.bytes(value)); - return new QueryOptions(ConsistencyLevel.ONE, buffers); - } ++ assertInvalidMessage("Partition key part b must be restricted since preceding part is", ++ "SELECT * FROM %s WHERE a = ? AND (c, d) >= (?, ?) ALLOW FILTERING", 0, 1, 1); + - private static ByteBuffer tuple(Integer... values) - { - List<AbstractType<?>> types = new ArrayList<>(values.length); - ByteBuffer[] buffers = new ByteBuffer[values.length]; - for (int i = 0; i < values.length; i++) - { - types.add(Int32Type.instance); - buffers[i] = ByteBufferUtil.bytes(values[i]); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c) IN ((?)) AND f = ? ALLOW FILTERING", 0, 1, 5), ++ row(0, 0, 1, 1, 1, 5)); + - TupleType type = new TupleType(types); - return type.buildValue(buffers); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c) IN ((?), (?)) AND f = ? ALLOW FILTERING", 0, 1, 2, 5), ++ row(0, 0, 1, 1, 1, 5), ++ row(0, 0, 2, 0, 0, 5)); + - private static ByteBuffer list(ByteBuffer... values) - { - return CollectionType.pack(Arrays.asList(values), values.length); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c, d) IN ((?, ?)) AND f = ? ALLOW FILTERING", 0, 1, 0, 3), ++ row(0, 0, 1, 0, 0, 3)); + - private static QueryOptions options(ByteBuffer... buffers) - { - return new QueryOptions(ConsistencyLevel.ONE, Arrays.asList(buffers)); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c) >= (?) AND f = ? ALLOW FILTERING", 0, 1, 5), ++ row(0, 0, 1, 1, 1, 5), ++ row(0, 0, 2, 0, 0, 5)); + - private static void checkRow(int rowIndex, UntypedResultSet results, Integer... expectedValues) - { - List<UntypedResultSet.Row> rows = newArrayList(results.iterator()); - UntypedResultSet.Row row = rows.get(rowIndex); - Iterator<ColumnSpecification> columns = row.getColumns().iterator(); - for (Integer expected : expectedValues) - { - String columnName = columns.next().name.toString(); - int actual = row.getInt(columnName); - assertEquals(String.format("Expected value %d for column %s in row %d, but got %s", actual, columnName, rowIndex, expected), - (long) expected, actual); - } ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND (c, d) >= (?, ?) AND f = ? ALLOW FILTERING", 0, 1, 1, 5), ++ row(0, 0, 1, 1, 1, 5), ++ row(0, 0, 2, 0, 0, 5)); + } } http://git-wip-us.apache.org/repos/asf/cassandra/blob/07ffe1b1/test/unit/org/apache/cassandra/cql3/SingleColumnRelationTest.java ---------------------------------------------------------------------- diff --cc test/unit/org/apache/cassandra/cql3/SingleColumnRelationTest.java index 2ad4bda,34d3bf1..604ec60 --- a/test/unit/org/apache/cassandra/cql3/SingleColumnRelationTest.java +++ b/test/unit/org/apache/cassandra/cql3/SingleColumnRelationTest.java @@@ -17,51 -17,129 +17,91 @@@ */ package org.apache.cassandra.cql3; -import java.util.Iterator; -import java.util.List; - -import org.junit.AfterClass; -import org.junit.BeforeClass; import org.junit.Test; -import org.apache.cassandra.SchemaLoader; -import org.apache.cassandra.db.ConsistencyLevel; -import org.apache.cassandra.exceptions.InvalidRequestException; -import org.apache.cassandra.gms.Gossiper; -import org.apache.cassandra.service.ClientState; - -import static com.google.common.collect.Lists.newArrayList; -import static org.apache.cassandra.cql3.QueryProcessor.process; -import static org.apache.cassandra.cql3.QueryProcessor.processInternal; -import static org.junit.Assert.assertEquals; +import java.util.ArrayList; +import java.util.List; -public class SingleColumnRelationTest +public class SingleColumnRelationTest extends CQLTester { - static ClientState clientState; - static String keyspace = "single_column_relation_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.partition_with_indices (a int, b int, c int, d int, e int, f int, PRIMARY KEY ((a, b), c, d, e))"); - executeSchemaChange("CREATE INDEX ON %s.partition_with_indices (c)"); - executeSchemaChange("CREATE INDEX ON %s.partition_with_indices (f)"); - - clientState = ClientState.forInternalCalls(); - } - - @AfterClass - public static void stopGossiper() + @Test + public void testInvalidCollectionEqualityRelation() throws Throwable { - Gossiper.instance.stop(); + createTable("CREATE TABLE %s (a int PRIMARY KEY, b set<int>, c list<int>, d map<int, int>)"); + createIndex("CREATE INDEX ON %s (b)"); + createIndex("CREATE INDEX ON %s (c)"); + createIndex("CREATE INDEX ON %s (d)"); + + assertInvalid("SELECT * FROM %s WHERE a = 0 AND b=?", set(0)); + assertInvalid("SELECT * FROM %s WHERE a = 0 AND c=?", list(0)); + assertInvalid("SELECT * FROM %s WHERE a = 0 AND d=?", map(0, 0)); } - private static void executeSchemaChange(String query) throws Throwable + @Test + public void testInvalidCollectionNonEQRelation() throws Throwable { - try - { - process(String.format(query, keyspace), ConsistencyLevel.ONE); - } catch (RuntimeException exc) - { - throw exc.getCause(); - } + createTable("CREATE TABLE %s (a int PRIMARY KEY, b set<int>, c int)"); + createIndex("CREATE INDEX ON %s (c)"); + execute("INSERT INTO %s (a, b, c) VALUES (0, {0}, 0)"); + + // non-EQ operators + assertInvalid("SELECT * FROM %s WHERE c = 0 AND b > ?", set(0)); + assertInvalid("SELECT * FROM %s WHERE c = 0 AND b >= ?", set(0)); + assertInvalid("SELECT * FROM %s WHERE c = 0 AND b < ?", set(0)); + assertInvalid("SELECT * FROM %s WHERE c = 0 AND b <= ?", set(0)); + assertInvalid("SELECT * FROM %s WHERE c = 0 AND b IN (?)", set(0)); } - private static UntypedResultSet execute(String query) throws Throwable + @Test + public void testLargeClusteringINValues() throws Throwable { - try - { - return processInternal(String.format(query, keyspace)); - } catch (RuntimeException exc) - { - if (exc.getCause() != null) - throw exc.getCause(); - throw exc; - } + createTable("CREATE TABLE %s (k int, c int, v int, PRIMARY KEY (k, c))"); + execute("INSERT INTO %s (k, c, v) VALUES (0, 0, 0)"); + List<Integer> inValues = new ArrayList<>(10000); + for (int i = 0; i < 10000; i++) + inValues.add(i); + assertRows(execute("SELECT * FROM %s WHERE k=? AND c IN ?", 0, inValues), + row(0, 0, 0) + ); } + + @Test - public void testPartitionWithIndex() throws Throwable ++ public void testMultiplePartitionKeyWithIndex() throws Throwable + { - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 0, 0, 0)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 1, 0, 1)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 0, 1, 1, 2)"); - - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 0, 0, 3)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 1, 0, 4)"); - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 1, 1, 1, 5)"); - - execute("INSERT INTO %s.partition_with_indices (a, b, c, d, e, f) VALUES (0, 0, 2, 0, 0, 5)"); - - UntypedResultSet results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND c = 1 ALLOW FILTERING"); - assertEquals(3, results.size()); - checkRow(0, results, 0, 0, 1, 0, 0, 3); - checkRow(1, results, 0, 0, 1, 1, 0, 4); - checkRow(2, results, 0, 0, 1, 1, 1, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND c = 1 AND d = 1 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 0, 4); - checkRow(1, results, 0, 0, 1, 1, 1, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND c >= 1 AND f = 5 ALLOW FILTERING"); - assertEquals(2, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - checkRow(1, results, 0, 0, 2, 0, 0, 5); - - results = execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND c = 1 AND d >= 1 AND f = 5 ALLOW FILTERING"); - assertEquals(1, results.size()); - checkRow(0, results, 0, 0, 1, 1, 1, 5); - } ++ createTable("CREATE TABLE %s (a int, b int, c int, d int, e int, f int, PRIMARY KEY ((a, b), c, d, e))"); ++ createIndex("CREATE INDEX ON %s (c)"); ++ createIndex("CREATE INDEX ON %s (f)"); + - @Test(expected=InvalidRequestException.class) - public void testMissingPartitionComponentAndFileringOnTheSecondClusteringColumnWithoutAllowFiltering() throws Throwable - { - execute("SELECT * FROM %s.partition_with_indices WHERE d >= 1 AND f = 5"); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 0, 0, 0); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 1, 0, 1); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 0, 1, 1, 2); + - @Test(expected=InvalidRequestException.class) - public void testMissingPartitionComponentWithSliceRestrictionOnIndexedColumn() throws Throwable - { - execute("SELECT * FROM %s.partition_with_indices WHERE a = 0 AND c >= 1 ALLOW FILTERING"); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 0, 0, 3); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 1, 0, 4); ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 1, 1, 1, 5); + - private static void checkRow(int rowIndex, UntypedResultSet results, Integer... expectedValues) - { - List<UntypedResultSet.Row> rows = newArrayList(results.iterator()); - UntypedResultSet.Row row = rows.get(rowIndex); - Iterator<ColumnSpecification> columns = row.getColumns().iterator(); - for (Integer expected : expectedValues) - { - String columnName = columns.next().name.toString(); - int actual = row.getInt(columnName); - assertEquals(String.format("Expected value %d for column %s in row %d, but got %s", actual, columnName, rowIndex, expected), - (long) expected, actual); - } ++ execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (?, ?, ?, ?, ?, ?)", 0, 0, 2, 0, 0, 5); ++ ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND c = ? ALLOW FILTERING", 0, 1), ++ row(0, 0, 1, 0, 0, 3), ++ row(0, 0, 1, 1, 0, 4), ++ row(0, 0, 1, 1, 1, 5)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND c = ? AND d = ? ALLOW FILTERING", 0, 1, 1), ++ row(0, 0, 1, 1, 0, 4), ++ row(0, 0, 1, 1, 1, 5)); ++ ++ assertInvalidMessage("Partition key part b must be restricted since preceding part is", ++ "SELECT * FROM %s WHERE a = ? AND c >= ? ALLOW FILTERING", 0, 1); ++ ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND c >= ? AND f = ? ALLOW FILTERING", 0, 1, 5), ++ row(0, 0, 1, 1, 1, 5), ++ row(0, 0, 2, 0, 0, 5)); ++ ++ assertRows(execute("SELECT * FROM %s WHERE a = ? AND c = ? AND d >= ? AND f = ? ALLOW FILTERING", 0, 1, 1, 5), ++ row(0, 0, 1, 1, 1, 5)); ++ ++ assertInvalidMessage("Cannot execute this query as it might involve data filtering and thus may have unpredictable performance. If you want to execute this query despite the performance unpredictability, use ALLOW FILTERING", ++ "SELECT * FROM %s WHERE a = ? AND d >= ? AND f = ?", 0, 1, 5); + } }
