http://git-wip-us.apache.org/repos/asf/cassandra/blob/0171259d/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
----------------------------------------------------------------------
diff --cc
test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
index 97fdf6a,6acab6f..9b10d0e
--- a/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
@@@ -23,10 -23,12 +23,11 @@@ import java.util.UUID
import org.junit.Test;
import junit.framework.Assert;
-import org.apache.cassandra.config.DatabaseDescriptor;
import org.apache.cassandra.cql3.UntypedResultSet;
-import org.apache.cassandra.cql3.CQLTester;
-import org.apache.cassandra.dht.Murmur3Partitioner;
+import org.apache.cassandra.cql3.restrictions.StatementRestrictions;
+ import org.apache.cassandra.exceptions.InvalidRequestException;
+import org.apache.cassandra.utils.ByteBufferUtil;
+import org.apache.cassandra.cql3.CQLTester;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
@@@ -36,7 -38,11 +37,6 @@@
*/
public class SelectTest extends CQLTester
{
- private static final ByteBuffer TOO_BIG = ByteBuffer.allocate(1024 * 65);
- @BeforeClass
- public static void setUp()
- {
- DatabaseDescriptor.setPartitioner(new Murmur3Partitioner());
- }
@Test
public void testSingleClustering() throws Throwable
@@@ -1367,887 -1238,30 +1367,915 @@@
}
@Test
+ public void testAlias() throws Throwable
+ {
+ createTable("CREATE TABLE %s (id int PRIMARY KEY, name text)");
+
+ for (int i = 0; i < 5; i++)
+ execute("INSERT INTO %s (id, name) VALUES (?, ?) USING TTL 10 AND
TIMESTAMP 0", i, Integer.toString(i));
+
+ assertInvalidMessage("Aliases aren't allowed in the where clause",
+ "SELECT id AS user_id, name AS user_name FROM %s
WHERE user_id = 0");
+
+ // test that select throws a meaningful exception for aliases in
order by clause
+ assertInvalidMessage("Aliases are not allowed in order by clause",
+ "SELECT id AS user_id, name AS user_name FROM %s
WHERE id IN (0) ORDER BY user_name");
+
+ }
+
+ @Test
+ public void testFilteringWithoutIndices() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a int, b int, c int, d int, e map<int,
int>, PRIMARY KEY (a, b))");
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c, d)
are not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = 1 AND d = 2 ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 1 AND c =
2 ALLOW FILTERING");
+ assertInvalidMessage("IN predicates on non-primary-key columns (c) is
not yet supported",
+ "SELECT * FROM %s WHERE a IN (1, 2) AND c IN (2,
3) ALLOW FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > 2 ALLOW FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS 1 ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY 1 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY null
ALLOW FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS ? ALLOW
FILTERING", unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY ? ALLOW
FILTERING", unset());
+
+ createTable("CREATE TABLE %s (a int, b int, c int, PRIMARY KEY(a))
WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 2, 8)");
+ execute("INSERT INTO %s (a, b, c) VALUES (3, 6, 4)");
+
+ assertRows(execute("SELECT * FROM %s WHERE c = 4 ALLOW FILTERING"),
+ row(1, 2, 4),
+ row(3, 6, 4));
+
+ // Checks filtering with null
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
"SELECT * FROM %s WHERE c = null");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
"SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Unsupported null value for column c", "SELECT *
FROM %s WHERE c = null ALLOW FILTERING");
+ assertInvalidMessage("Unsupported null value for column c", "SELECT *
FROM %s WHERE c > null ALLOW FILTERING");
+
+ // Checks filtering with unset
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c = ?", unset());
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > ?", unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
unset());
+ }
+
+ @Test
+ public void testFilteringOnStaticColumnWithoutIndices() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a int, b int, s int static, c int,
PRIMARY KEY (a, b))");
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c, s)
are not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = 1 AND s = 2 ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 1 AND s =
2 ALLOW FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE s > 2 ALLOW FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE s = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE s > null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE s = ? ALLOW FILTERING",
unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (s) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE s > ? ALLOW FILTERING",
unset());
+ }
+
+ @Test
+ public void testFilteringOnCompactTablesWithoutIndices() throws Throwable
+ {
+ //----------------------------------------------
+ // Test COMPACT table with clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int, b int, c int, PRIMARY KEY (a,
b)) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 3, 6)");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 4, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 3, 7)");
+
+ // Lets add some tombstones to make sure that filtering handle them
properly
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 1, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 2, 7)");
+ execute("DELETE FROM %s WHERE a = 1 AND b = 1");
+ execute("DELETE FROM %s WHERE a = 2 AND b = 2");
+
+ flush();
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 4 AND c =
4 ALLOW FILTERING");
+
+ assertInvalidMessage("IN predicates on non-primary-key columns (c) is
not yet supported",
+ "SELECT * FROM %s WHERE a IN (1, 2) AND c IN (6,
7) ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > 4 ALLOW FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+
+ //----------------------------------------------
+ // Test COMPACT table without clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int PRIMARY KEY, b int, c int) WITH
COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 1, 6)");
+ execute("INSERT INTO %s (a, b, c) VALUES (3, 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (4, 1, 7)");
+
+ // Lets add some tombstones to make sure that filtering handle them
properly
+ execute("INSERT INTO %s (a, b, c) VALUES (0, 1, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES (5, 2, 7)");
+ execute("DELETE FROM %s WHERE a = 0");
+ execute("DELETE FROM %s WHERE a = 5");
+
+ flush();
+
+ // Checks filtering
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE a = 1 AND b = 4 AND c =
4");
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 1 AND b = 2 AND c = 4
ALLOW FILTERING"),
+ row(1, 2, 4));
+
+ assertInvalidMessage("IN predicates on non-primary-key columns (c) is
not yet supported",
+ "SELECT * FROM %s WHERE a IN (1, 2) AND c IN (6,
7)");
+
+ assertInvalidMessage("IN predicates on non-primary-key columns (c) is
not yet supported",
+ "SELECT * FROM %s WHERE a IN (1, 2) AND c IN (6,
7) ALLOW FILTERING");
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > 4");
+
+ assertRows(execute("SELECT * FROM %s WHERE c > 4 ALLOW FILTERING"),
+ row(2, 1, 6),
+ row(4, 1, 7));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE b < 3 AND c <= 4");
+
+ assertRows(execute("SELECT * FROM %s WHERE b < 3 AND c <= 4 ALLOW
FILTERING"),
+ row(1, 2, 4),
+ row(3, 2, 4));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c >= 3 AND c <= 6");
+
+ assertRows(execute("SELECT * FROM %s WHERE c >= 3 AND c <= 6 ALLOW
FILTERING"),
+ row(1, 2, 4),
+ row(2, 1, 6),
+ row(3, 2, 4));
+
+ // Checks filtering with null
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ }
+
+ @Test
+ public void testFilteringWithoutIndicesWithCollections() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a int, b int, c list<int>, d set<int>,
e map<int, int>, PRIMARY KEY (a, b))");
+
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 2, [1, 6], {2,
12}, {1: 6})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 3, [3, 2], {6, 4},
{3: 2})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 4, [1, 2], {2, 4},
{1: 2})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (2, 3, [3, 6], {6,
12}, {3: 6})");
+
+ flush();
+
+ // Checks filtering for lists
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING");
+
+ // Checks filtering for sets
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS 4 ALLOW
FILTERING");
+
+ // Checks filtering for maps
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS 2 ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY 2 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY null
ALLOW FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e[null] = 2 ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e[1] = null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e[?] = 2 ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e[1] = ? ALLOW
FILTERING",
+ unset());
+ }
+
+ @Test
+ public void testFilteringWithoutIndicesWithFrozenCollections() throws
Throwable
+ {
+ createTable("CREATE TABLE %s (a int, b int, c frozen<list<int>>, d
frozen<set<int>>, e frozen<map<int, int>>, PRIMARY KEY (a, b))");
+
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 2, [1, 6], {2,
12}, {1: 6})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 3, [3, 2], {6, 4},
{3: 2})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 4, [1, 2], {2, 4},
{1: 2})");
+ execute("INSERT INTO %s (a, b, c, d, e) VALUES (2, 3, [3, 6], {6,
12}, {3: 6})");
+
+ flush();
+
+ // Checks filtering for lists
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = [3, 2] ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > [1, 5] AND c < [3,
6] ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING");
+
+ // Checks filtering for sets
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d = {6, 4} ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d > {4, 5} AND d < {6}
ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS 4 ALLOW
FILTERING");
+
+ // Checks filtering for maps
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e = {1 : 2} ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e > {1 : 4} AND e < {3 : 6} ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS 2 ALLOW
FILTERING");
+
+ assertInvalidMessage("Map-entry equality predicates on frozen map
column e are not supported",
+ "SELECT * FROM %s WHERE e[1] = 6 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY null
ALLOW FILTERING");
+ assertInvalidMessage("Map-entry equality predicates on frozen map
column e are not supported",
+ "SELECT * FROM %s WHERE e[null] = 2 ALLOW
FILTERING");
+ assertInvalidMessage("Map-entry equality predicates on frozen map
column e are not supported",
+ "SELECT * FROM %s WHERE e[1] = null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (d) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE d CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (e) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE e CONTAINS KEY ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Map-entry equality predicates on frozen map
column e are not supported",
+ "SELECT * FROM %s WHERE e[?] = 2 ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Map-entry equality predicates on frozen map
column e are not supported",
+ "SELECT * FROM %s WHERE e[1] = ? ALLOW
FILTERING",
+ unset());
+ }
+
+ @Test
+ public void testFilteringOnCompactTablesWithoutIndicesAndWithLists()
throws Throwable
+ {
+ //----------------------------------------------
+ // Test COMPACT table with clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int, b int, c frozen<list<int>>,
PRIMARY KEY (a, b)) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, [4, 2])");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 3, [6, 2])");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 4, [4, 1])");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 3, [7, 1])");
+
+ flush();
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 4 AND c =
[4, 1] ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > [4, 2] ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE b <= 3 AND c < [6, 2]
ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING");
+
+ assertInvalidMessage("Cannot use CONTAINS KEY on non-map column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY 2 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+
+ //----------------------------------------------
+ // Test COMPACT table without clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int PRIMARY KEY, b int, c
frozen<list<int>>) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, [4, 2])");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 1, [6, 2])");
+ execute("INSERT INTO %s (a, b, c) VALUES (3, 2, [4, 1])");
+ execute("INSERT INTO %s (a, b, c) VALUES (4, 1, [7, 1])");
+
+ flush();
+
+ // Checks filtering
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE a = 1 AND b = 2 AND c =
[4, 2]");
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 1 AND b = 2 AND c =
[4, 2] ALLOW FILTERING"),
+ row(1, 2, list(4, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > [4, 2]");
+
+ assertRows(execute("SELECT * FROM %s WHERE c > [4, 2] ALLOW
FILTERING"),
+ row(2, 1, list(6, 2)),
+ row(4, 1, list(7, 1)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE b < 3 AND c <= [4, 2]");
+
+ assertRows(execute("SELECT * FROM %s WHERE b < 3 AND c <= [4, 2]
ALLOW FILTERING"),
+ row(1, 2, list(4, 2)),
+ row(3, 2, list(4, 1)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c >= [4, 3] AND c <=
[7]");
+
+ assertRows(execute("SELECT * FROM %s WHERE c >= [4, 3] AND c <= [7]
ALLOW FILTERING"),
+ row(2, 1, list(6, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS 2");
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING"),
+ row(1, 2, list(4, 2)),
+ row(2, 1, list(6, 2)));
+
+ assertInvalidMessage("Cannot use CONTAINS KEY on non-map column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY 2 ALLOW
FILTERING");
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 AND c
CONTAINS 6 ALLOW FILTERING"),
+ row(2, 1, list(6, 2)));
+
+ // Checks filtering with null
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ }
+
+ @Test
+ public void testFilteringOnCompactTablesWithoutIndicesAndWithSets()
throws Throwable
+ {
+ //----------------------------------------------
+ // Test COMPACT table with clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int, b int, c frozen<set<int>>,
PRIMARY KEY (a, b)) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, {4, 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 3, {6, 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 4, {4, 1})");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 3, {7, 1})");
+
+ flush();
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 4 AND c =
{4, 1} ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > {4, 2} ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c >= {4, 2} AND c <= {6,
4} ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING");
+
+ assertInvalidMessage("Cannot use CONTAINS KEY on non-map column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY 2 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+
+ //----------------------------------------------
+ // Test COMPACT table without clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int PRIMARY KEY, b int, c
frozen<set<int>>) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, {4, 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 1, {6, 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (3, 2, {4, 1})");
+ execute("INSERT INTO %s (a, b, c) VALUES (4, 1, {7, 1})");
+
+ flush();
+
+ // Checks filtering
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE a = 1 AND b = 2 AND c =
{4, 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 1 AND b = 2 AND c =
{4, 2} ALLOW FILTERING"),
+ row(1, 2, set(4, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > {4, 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE c > {4, 2} ALLOW
FILTERING"),
+ row(2, 1, set(6, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE b < 3 AND c <= {4, 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE b < 3 AND c <= {4, 2}
ALLOW FILTERING"),
+ row(1, 2, set(4, 2)),
+ row(4, 1, set(1, 7)),
+ row(3, 2, set(4, 1)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c >= {4, 3} AND c <=
{7}");
+
+ assertRows(execute("SELECT * FROM %s WHERE c >= {5, 2} AND c <= {7}
ALLOW FILTERING"),
+ row(2, 1, set(6, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS 2");
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING"),
+ row(1, 2, set(4, 2)),
+ row(2, 1, set(6, 2)));
+
+ assertInvalidMessage("Cannot use CONTAINS KEY on non-map column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY 2 ALLOW
FILTERING");
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 AND c
CONTAINS 6 ALLOW FILTERING"),
+ row(2, 1, set(6, 2)));
+
+ // Checks filtering with null
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ }
+
+ @Test
+ public void testIndexQueryWithValueOver64K() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a int, b int, c blob, PRIMARY KEY (a,
b))");
+ createIndex("CREATE INDEX test ON %s (c)");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, 0,
ByteBufferUtil.bytes(1));
+ execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, 1,
ByteBufferUtil.bytes(2));
+
+ assertInvalidMessage("Index expression values may not be larger than
64K",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
TOO_BIG);
+ }
+
+ @Test
+ public void testFilteringOnCompactTablesWithoutIndicesAndWithMaps()
throws Throwable
+ {
+ //----------------------------------------------
+ // Test COMPACT table with clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int, b int, c frozen<map<int, int>>,
PRIMARY KEY (a, b)) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, {4 : 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 3, {6 : 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 4, {4 : 1})");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 3, {7 : 1})");
+
+ flush();
+
+ // Checks filtering
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE a = 1 AND b = 4 AND c =
{4 : 1} ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > {4 : 2} ALLOW
FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE b <= 3 AND c < {6 : 2}
ALLOW FILTERING");
+
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING");
+
+ // Checks filtering with null
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS KEY null
ALLOW FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Predicates on non-primary-key columns (c) are
not yet supported for non secondary index queries",
+ "SELECT * FROM %s WHERE c CONTAINS KEY ? ALLOW
FILTERING",
+ unset());
+
+ //----------------------------------------------
+ // Test COMPACT table without clustering columns
+ //----------------------------------------------
+ createTable("CREATE TABLE %s (a int PRIMARY KEY, b int, c
frozen<map<int, int>>) WITH COMPACT STORAGE");
+
+ execute("INSERT INTO %s (a, b, c) VALUES (1, 2, {4 : 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (2, 1, {6 : 2})");
+ execute("INSERT INTO %s (a, b, c) VALUES (3, 2, {4 : 1})");
+ execute("INSERT INTO %s (a, b, c) VALUES (4, 1, {7 : 1})");
+
+ flush();
+
+ // Checks filtering
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE a = 1 AND b = 2 AND c =
{4 : 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 1 AND b = 2 AND c = {4
: 2} ALLOW FILTERING"),
+ row(1, 2, map(4, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > {4 : 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE c > {4 : 2} ALLOW
FILTERING"),
+ row(2, 1, map(6, 2)),
+ row(4, 1, map(7, 1)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE b < 3 AND c <= {4 : 2}");
+
+ assertRows(execute("SELECT * FROM %s WHERE b < 3 AND c <= {4 : 2}
ALLOW FILTERING"),
+ row(1, 2, map(4, 2)),
+ row(3, 2, map(4, 1)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c >= {4 : 3} AND c <= {7
: 1}");
+
+ assertRows(execute("SELECT * FROM %s WHERE c >= {5 : 2} AND c <= {7 :
0} ALLOW FILTERING"),
+ row(2, 1, map(6, 2)));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS 2");
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 ALLOW
FILTERING"),
+ row(1, 2, map(4, 2)),
+ row(2, 1, map(6, 2)));
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS KEY 4 ALLOW
FILTERING"),
+ row(1, 2, map(4, 2)),
+ row(3, 2, map(4, 1)));
+
+ assertRows(execute("SELECT * FROM %s WHERE c CONTAINS 2 AND c
CONTAINS KEY 6 ALLOW FILTERING"),
+ row(2, 1, map(6, 2)));
+
+ // Checks filtering with null
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c = null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c = null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c > null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c > null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS null ALLOW
FILTERING");
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT * FROM %s WHERE c CONTAINS KEY null");
+ assertInvalidMessage("Unsupported null value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY null
ALLOW FILTERING");
+
+ // Checks filtering with unset
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c = ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c > ? ALLOW FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS ? ALLOW
FILTERING",
+ unset());
+ assertInvalidMessage("Unsupported unset value for column c",
+ "SELECT * FROM %s WHERE c CONTAINS KEY ? ALLOW
FILTERING",
+ unset());
+ }
+
+ /**
+ * Check select with and without compact storage, with different column
+ * order. See CASSANDRA-10988
+ */
+ @Test
+ public void testClusteringOrderWithSlice() throws Throwable
+ {
+ for (String compactOption : new String[] { "", " COMPACT STORAGE AND"
})
+ {
+ // non-compound, ASC order
+ createTable("CREATE TABLE %s (a text, b int, PRIMARY KEY (a, b))
WITH" +
+ compactOption +
+ " CLUSTERING ORDER BY (b ASC)");
+
+ execute("INSERT INTO %s (a, b) VALUES ('a', 2)");
+ execute("INSERT INTO %s (a, b) VALUES ('a', 3)");
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0"),
+ row("a", 2),
+ row("a", 3));
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0
ORDER BY b DESC"),
+ row("a", 3),
+ row("a", 2));
+
+ // non-compound, DESC order
+ createTable("CREATE TABLE %s (a text, b int, PRIMARY KEY (a, b))
WITH" +
+ compactOption +
+ " CLUSTERING ORDER BY (b DESC)");
+
+ execute("INSERT INTO %s (a, b) VALUES ('a', 2)");
+ execute("INSERT INTO %s (a, b) VALUES ('a', 3)");
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0"),
+ row("a", 3),
+ row("a", 2));
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0
ORDER BY b ASC"),
+ row("a", 2),
+ row("a", 3));
+
+ // compound, first column DESC order
+ createTable("CREATE TABLE %s (a text, b int, c int, PRIMARY KEY
(a, b, c)) WITH" +
+ compactOption +
+ " CLUSTERING ORDER BY (b DESC)"
+ );
+
+ execute("INSERT INTO %s (a, b, c) VALUES ('a', 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES ('a', 3, 5)");
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0"),
+ row("a", 3, 5),
+ row("a", 2, 4));
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0
ORDER BY b ASC"),
+ row("a", 2, 4),
+ row("a", 3, 5));
+
+ // compound, mixed order
+ createTable("CREATE TABLE %s (a text, b int, c int, PRIMARY KEY
(a, b, c)) WITH" +
+ compactOption +
+ " CLUSTERING ORDER BY (b ASC, c DESC)"
+ );
+
+ execute("INSERT INTO %s (a, b, c) VALUES ('a', 2, 4)");
+ execute("INSERT INTO %s (a, b, c) VALUES ('a', 3, 5)");
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0"),
+ row("a", 2, 4),
+ row("a", 3, 5));
+
+ assertRows(execute("SELECT * FROM %s WHERE a = 'a' AND b > 0
ORDER BY b ASC"),
+ row("a", 2, 4),
+ row("a", 3, 5));
+ }
+ }
++
++ @Test
+ public void testOverlyLargeSelectPK() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a text, b text, PRIMARY KEY ((a), b))");
+
+ assertInvalidThrow(InvalidRequestException.class,
+ "SELECT * FROM %s WHERE a = ?", new
String(TOO_BIG.array()));
+ }
+
+ @Test
+ public void testOverlyLargeSelectCK() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a text, b text, PRIMARY KEY ((a), b))");
+
+ assertInvalidThrow(InvalidRequestException.class,
+ "SELECT * FROM %s WHERE a = 'foo' AND b = ?", new
String(TOO_BIG.array()));
+ }
+
+ @Test
+ public void testOverlyLargeSelectKeyIn() throws Throwable
+ {
+ createTable("CREATE TABLE %s (a text, b text, c text, d text, PRIMARY
KEY ((a, b, c), d))");
+
+ assertInvalidThrow(InvalidRequestException.class,
+ "SELECT * FROM %s WHERE a = 'foo' AND b= 'bar' AND
c IN (?, ?)",
+ new String(TOO_BIG.array()), new
String(TOO_BIG.array()));
+ }
}