cassandra-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From jmcken...@apache.org
Subject [01/32] cassandra git commit: Migrate CQL tests from dtest to unit tests
Date Wed, 24 Jun 2015 16:14:54 GMT
Repository: cassandra
Updated Branches:
  refs/heads/trunk 7392fb96d -> bc9b0be32


http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/test/unit/org/apache/cassandra/cql3/validation/operations/SelectOrderedPartitionerTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/operations/SelectOrderedPartitionerTest.java b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectOrderedPartitionerTest.java
new file mode 100644
index 0000000..a2ba71e
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectOrderedPartitionerTest.java
@@ -0,0 +1,325 @@
+package org.apache.cassandra.cql3.validation.operations;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertNull;
+import static org.junit.Assert.assertEquals;
+import org.apache.cassandra.config.DatabaseDescriptor;
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.dht.ByteOrderedPartitioner;
+
+/**
+ * SELECT statement tests that require a ByteOrderedPartitioner
+ */
+public class SelectOrderedPartitionerTest extends CQLTester
+{
+    @BeforeClass
+    public static void setUp()
+    {
+        DatabaseDescriptor.setPartitioner(new ByteOrderedPartitioner());
+    }
+
+    @Test
+    public void testTokenFunctionWithSingleColumnPartitionKey() throws Throwable
+    {
+        createTable("CREATE TABLE IF NOT EXISTS %s (a int PRIMARY KEY, b text)");
+        execute("INSERT INTO %s (a, b) VALUES (0, 'a')");
+
+        assertRows(execute("SELECT * FROM %s WHERE token(a) >= token(?)", 0), row(0, "a"));
+        assertRows(execute("SELECT * FROM %s WHERE token(a) >= token(?) and token(a) < token(?)", 0, 1), row(0, "a"));
+        assertInvalid("SELECT * FROM %s WHERE token(a) > token(?)", "a");
+        assertInvalid("SELECT * FROM %s WHERE token(a, b) >= token(?, ?)", "b", 0);
+        assertInvalid("SELECT * FROM %s WHERE token(a) >= token(?) and token(a) >= token(?)", 0, 1);
+        assertInvalid("SELECT * FROM %s WHERE token(a) >= token(?) and token(a) = token(?)", 0, 1);
+        assertInvalidSyntax("SELECT * FROM %s WHERE token(a) = token(?) and token(a) IN (token(?))", 0, 1);
+    }
+
+    @Test
+    public void testTokenFunctionWithPartitionKeyAndClusteringKeyArguments() throws Throwable
+    {
+        createTable("CREATE TABLE IF NOT EXISTS %s (a int, b text, PRIMARY KEY (a, b))");
+        assertInvalid("SELECT * FROM %s WHERE token(a, b) > token(0, 'c')");
+    }
+
+    @Test
+    public void testTokenFunctionWithMultiColumnPartitionKey() throws Throwable
+    {
+        createTable("CREATE TABLE IF NOT EXISTS %s (a int, b text, PRIMARY KEY ((a, b)))");
+        execute("INSERT INTO %s (a, b) VALUES (0, 'a')");
+        execute("INSERT INTO %s (a, b) VALUES (0, 'b')");
+        execute("INSERT INTO %s (a, b) VALUES (0, 'c')");
+
+        assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(?, ?)", 0, "a"),
+                   row(0, "b"),
+                   row(0, "c"));
+        assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(?, ?) and token(a, b) < token(?, ?)",
+                           0, "a",
+                           0, "d"),
+                   row(0, "b"),
+                   row(0, "c"));
+        assertInvalid("SELECT * FROM %s WHERE token(a) > token(?) and token(b) > token(?)", 0, "a");
+        assertInvalid("SELECT * FROM %s WHERE token(a) > token(?, ?) and token(a) < token(?, ?) and token(b) > token(?, ?) ", 0, "a", 0, "d", 0, "a");
+        assertInvalid("SELECT * FROM %s WHERE token(b, a) > token(0, 'c')");
+    }
+
+    @Test
+    public void testTokenFunctionWithCompoundPartitionAndClusteringCols() throws Throwable
+    {
+        createTable("CREATE TABLE IF NOT EXISTS %s (a int, b int, c int, d int, PRIMARY KEY ((a, b), c, d))");
+        // just test that the queries don't error
+        execute("SELECT * FROM %s WHERE token(a, b) > token(0, 0) AND c > 10 ALLOW FILTERING;");
+        execute("SELECT * FROM %s WHERE c > 10 AND token(a, b) > token(0, 0) ALLOW FILTERING;");
+        execute("SELECT * FROM %s WHERE token(a, b) > token(0, 0) AND (c, d) > (0, 0) ALLOW FILTERING;");
+        execute("SELECT * FROM %s WHERE (c, d) > (0, 0) AND token(a, b) > token(0, 0) ALLOW FILTERING;");
+    }
+
+    /**
+     * Test undefined columns
+     * migrated from cql_tests.py:TestCQL.undefined_column_handling_test()
+     */
+    @Test
+    public void testUndefinedColumns() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, v1 int, v2 int,)");
+
+        execute("INSERT INTO %s (k, v1, v2) VALUES (0, 0, 0)");
+        execute("INSERT INTO %s (k, v1) VALUES (1, 1)");
+        execute("INSERT INTO %s (k, v1, v2) VALUES (2, 2, 2)");
+
+        Object[][] rows = getRows(execute("SELECT v2 FROM %s"));
+        assertEquals(0, rows[0][0]);
+        assertEquals(null, rows[1][0]);
+        assertEquals(2, rows[2][0]);
+
+        rows = getRows(execute("SELECT v2 FROM %s WHERE k = 1"));
+        assertEquals(1, rows.length);
+        assertNull(rows[0][0]);
+    }
+
+    /**
+     * Check table with only a PK (#4361),
+     * migrated from cql_tests.py:TestCQL.only_pk_test()
+     */
+    @Test
+    public void testPrimaryKeyOnly() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, PRIMARY KEY (k, c))");
+
+        for (int k = 0; k < 2; k++)
+            for (int c = 0; c < 2; c++)
+                execute("INSERT INTO %s (k, c) VALUES (?, ?)", k, c);
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(0, 0),
+                   row(0, 1),
+                   row(1, 0),
+                   row(1, 1));
+
+        // Check for dense tables too
+        createTable(" CREATE TABLE %s (k int, c int, PRIMARY KEY (k, c)) WITH COMPACT STORAGE");
+
+        for (int k = 0; k < 2; k++)
+            for (int c = 0; c < 2; c++)
+                execute("INSERT INTO %s (k, c) VALUES (?, ?)", k, c);
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(0, 0),
+                   row(0, 1),
+                   row(1, 0),
+                   row(1, 1));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.composite_index_with_pk_test()
+     */
+    @Test
+    public void testCompositeIndexWithPK() throws Throwable
+    {
+        createTable("CREATE TABLE %s (blog_id int, time1 int, time2 int, author text, content text, PRIMARY KEY (blog_id, time1, time2))");
+
+        createIndex("CREATE INDEX ON %s(author)");
+
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, ?)", 1, 0, 0, "foo", "bar1");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, ?)", 1, 0, 1, "foo", "bar2");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, ?)", 2, 1, 0, "foo", "baz");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, ?)", 3, 0, 1, "gux", "qux");
+
+        assertRows(execute("SELECT blog_id, content FROM %s WHERE author='foo'"),
+                   row(1, "bar1"),
+                   row(1, "bar2"),
+                   row(2, "baz"));
+
+        assertRows(execute("SELECT blog_id, content FROM %s WHERE time1 > 0 AND author='foo' ALLOW FILTERING"),
+                   row(2, "baz"));
+
+        assertRows(execute("SELECT blog_id, content FROM %s WHERE time1 = 1 AND author='foo' ALLOW FILTERING"),
+                   row(2, "baz"));
+
+        assertRows(execute("SELECT blog_id, content FROM %s WHERE time1 = 1 AND time2 = 0 AND author='foo' ALLOW FILTERING"),
+                   row(2, "baz"));
+
+        assertEmpty(execute("SELECT content FROM %s WHERE time1 = 1 AND time2 = 1 AND author='foo' ALLOW FILTERING"));
+
+        assertEmpty(execute("SELECT content FROM %s WHERE time1 = 1 AND time2 > 0 AND author='foo' ALLOW FILTERING"));
+
+        assertInvalid("SELECT content FROM %s WHERE time2 >= 0 AND author='foo'");
+
+        execute("SELECT blog_id, content FROM %s WHERE time1 > 0 AND author='foo'");
+        execute("SELECT blog_id, content FROM %s WHERE time1 = 1 AND author='foo'");
+        execute("SELECT blog_id, content FROM %s WHERE time1 = 1 AND time2 = 0 AND author='foo'");
+        execute("SELECT content FROM %s WHERE time1 = 1 AND time2 = 1 AND author='foo'");
+        execute("SELECT content FROM %s WHERE time1 = 1 AND time2 > 0 AND author='foo'");
+    }
+
+    /**
+     * Test for LIMIT bugs from 4579,
+     * migrated from cql_tests.py:TestCQL.limit_bugs_test()
+     */
+    @Test
+    public void testLimitBug() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b int, c int, d int, e int, PRIMARY KEY (a, b))");
+
+        execute("INSERT INTO %s (a, b, c, d, e) VALUES (1, 1, 1, 1, 1);");
+        execute("INSERT INTO %s (a, b, c, d, e) VALUES (2, 2, 2, 2, 2);");
+        execute("INSERT INTO %s (a, b, c, d, e) VALUES (3, 3, 3, 3, 3);");
+        execute("INSERT INTO %s (a, b, c, d, e) VALUES (4, 4, 4, 4, 4);");
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(1, 1, 1, 1, 1),
+                   row(2, 2, 2, 2, 2),
+                   row(3, 3, 3, 3, 3),
+                   row(4, 4, 4, 4, 4));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 1"),
+                   row(1, 1, 1, 1, 1));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 2"),
+                   row(1, 1, 1, 1, 1),
+                   row(2, 2, 2, 2, 2));
+
+        createTable("CREATE TABLE %s (a int primary key, b int, c int,)");
+
+        execute("INSERT INTO %s (a, b, c) VALUES (1, 1, 1)");
+        execute("INSERT INTO %s (a, b, c) VALUES (2, 2, 2)");
+        execute("INSERT INTO %s (a, b, c) VALUES (3, 3, 3)");
+        execute("INSERT INTO %s (a, b, c) VALUES (4, 4, 4)");
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(1, 1, 1),
+                   row(2, 2, 2),
+                   row(3, 3, 3),
+                   row(4, 4, 4));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 1"),
+                   row(1, 1, 1));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 2"),
+                   row(1, 1, 1),
+                   row(2, 2, 2));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 3"),
+                   row(1, 1, 1),
+                   row(2, 2, 2),
+                   row(3, 3, 3));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 4"),
+                   row(1, 1, 1),
+                   row(2, 2, 2),
+                   row(3, 3, 3),
+                   row(4, 4, 4));
+
+        assertRows(execute("SELECT * FROM %s LIMIT 5"),
+                   row(1, 1, 1),
+                   row(2, 2, 2),
+                   row(3, 3, 3),
+                   row(4, 4, 4));
+    }
+
+    /**
+     * Test for #4612 bug and more generally order by when multiple C* rows are queried
+     * migrated from cql_tests.py:TestCQL.order_by_multikey_test()
+     */
+    @Test
+    public void testOrderByMultikey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (my_id varchar, col1 int, col2 int, value varchar, PRIMARY KEY (my_id, col1, col2))");
+
+        execute("INSERT INTO %s (my_id, col1, col2, value) VALUES ( 'key1', 1, 1, 'a');");
+        execute("INSERT INTO %s (my_id, col1, col2, value) VALUES ( 'key2', 3, 3, 'a');");
+        execute("INSERT INTO %s (my_id, col1, col2, value) VALUES ( 'key3', 2, 2, 'b');");
+        execute("INSERT INTO %s (my_id, col1, col2, value) VALUES ( 'key4', 2, 1, 'b');");
+
+        assertRows(execute("SELECT col1 FROM %s WHERE my_id in('key1', 'key2', 'key3') ORDER BY col1"),
+                   row(1), row(2), row(3));
+
+        assertRows(execute("SELECT col1, value, my_id, col2 FROM %s WHERE my_id in('key3', 'key4') ORDER BY col1, col2"),
+                   row(2, "b", "key4", 1), row(2, "b", "key3", 2));
+
+        assertInvalid("SELECT col1 FROM %s ORDER BY col1");
+        assertInvalid("SELECT col1 FROM %s WHERE my_id > 'key1' ORDER BY col1");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.composite_index_collections_test()
+     */
+    @Test
+    public void testIndexOnCompositeWithCollections() throws Throwable
+    {
+        createTable("CREATE TABLE %s (blog_id int, time1 int, time2 int, author text, content set<text>, PRIMARY KEY (blog_id, time1, time2))");
+
+        createIndex("CREATE INDEX ON %s (author)");
+
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, { 'bar1', 'bar2' })", 1, 0, 0, "foo");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, { 'bar2', 'bar3' })", 1, 0, 1, "foo");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, { 'baz' })", 2, 1, 0, "foo");
+        execute("INSERT INTO %s (blog_id, time1, time2, author, content) VALUES (?, ?, ?, ?, { 'qux' })", 3, 0, 1, "gux");
+
+        assertRows(execute("SELECT blog_id, content FROM %s WHERE author='foo'"),
+                   row(1, set("bar1", "bar2")),
+                   row(1, set("bar2", "bar3")),
+                   row(2, set("baz")));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.truncate_clean_cache_test()
+     */
+    @Test
+    public void testTruncateWithCaching() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, v1 int, v2 int,) WITH CACHING = ALL;");
+
+        for (int i = 0; i < 3; i++)
+            execute("INSERT INTO %s (k, v1, v2) VALUES (?, ?, ?)", i, i, i * 2);
+
+        assertRows(execute("SELECT v1, v2 FROM %s WHERE k IN (0, 1, 2)"),
+                   row(0, 0),
+                   row(1, 2),
+                   row(2, 4));
+
+        execute("TRUNCATE %s");
+
+        assertEmpty(execute("SELECT v1, v2 FROM %s WHERE k IN (0, 1, 2)"));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.range_key_ordered_test()
+     */
+    @Test
+    public void testRangeKey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY)");
+
+        execute("INSERT INTO %s (k) VALUES (-1)");
+        execute("INSERT INTO %s (k) VALUES ( 0)");
+        execute("INSERT INTO %s (k) VALUES ( 1)");
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(0),
+                   row(1),
+                   row(-1));
+
+        assertInvalid("SELECT * FROM %s WHERE k >= -1 AND k < 1");
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/test/unit/org/apache/cassandra/cql3/validation/operations/SelectSingleColumnRelationTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/operations/SelectSingleColumnRelationTest.java b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectSingleColumnRelationTest.java
new file mode 100644
index 0000000..e950e7a
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectSingleColumnRelationTest.java
@@ -0,0 +1,109 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.cql3.validation.operations;
+
+import org.junit.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import org.apache.cassandra.cql3.CQLTester;
+
+public class SelectSingleColumnRelationTest extends CQLTester
+{
+    @Test
+    public void testInvalidCollectionEqualityRelation() throws Throwable
+    {
+        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));
+    }
+
+    @Test
+    public void testInvalidCollectionNonEQRelation() throws Throwable
+    {
+        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));
+    }
+
+    @Test
+    public void testLargeClusteringINValues() throws Throwable
+    {
+        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 testMultiplePartitionKeyWithIndex() throws Throwable
+    {
+        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)");
+
+        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);
+
+        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);
+
+        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);
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
new file mode 100644
index 0000000..c8c1f1a
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/SelectTest.java
@@ -0,0 +1,1238 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.cql3.validation.operations;
+
+import java.nio.ByteBuffer;
+import java.util.UUID;
+
+import org.junit.BeforeClass;
+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 static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Test column ranges and ordering with static column in table
+ */
+public class SelectTest extends CQLTester
+{
+    @BeforeClass
+    public static void setUp()
+    {
+        DatabaseDescriptor.setPartitioner(new Murmur3Partitioner());
+    }
+
+    @Test
+    public void testSingleClustering() throws Throwable
+    {
+        createTable("CREATE TABLE %s (p text, c text, v text, s text static, PRIMARY KEY (p, c))");
+
+        execute("INSERT INTO %s(p, c, v, s) values (?, ?, ?, ?)", "p1", "k1", "v1", "sv1");
+        execute("INSERT INTO %s(p, c, v) values (?, ?, ?)", "p1", "k2", "v2");
+        execute("INSERT INTO %s(p, s) values (?, ?)", "p2", "sv2");
+
+        assertRows(execute("SELECT * FROM %s WHERE p=?", "p1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=?", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // Ascending order
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // Descending order
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // No order with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c =?", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k0"));
+
+        // Ascending with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c =? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k0"));
+
+        // Descending with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c =? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k0"));
+
+        // IN
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?)", "p1", "k1", "k2"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c ASC", "p1", "k1", "k2"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c DESC", "p1", "k1", "k2"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+    }
+
+    @Test
+    public void testSingleClusteringReversed() throws Throwable
+    {
+        createTable("CREATE TABLE %s (p text, c text, v text, s text static, PRIMARY KEY (p, c)) WITH CLUSTERING ORDER BY (c DESC)");
+
+        execute("INSERT INTO %s(p, c, v, s) values (?, ?, ?, ?)", "p1", "k1", "v1", "sv1");
+        execute("INSERT INTO %s(p, c, v) values (?, ?, ?)", "p1", "k2", "v2");
+        execute("INSERT INTO %s(p, s) values (?, ?)", "p2", "sv2");
+
+        assertRows(execute("SELECT * FROM %s WHERE p=?", "p1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=?", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // Ascending order
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c ASC", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // Descending order
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? ORDER BY c DESC", "p2"),
+            row("p2", null, "sv2", null)
+        );
+
+        // No order with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=?", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c=?", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=?", "p1", "k0"));
+
+        // Ascending with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c ASC", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c=? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c ASC", "p1", "k0"));
+
+        // Descending with one relation
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k2"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c>=? ORDER BY c DESC", "p1", "k3"));
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c=? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k1"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE p=? AND c<=? ORDER BY c DESC", "p1", "k0"));
+
+        // IN
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?)", "p1", "k1", "k2"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c ASC", "p1", "k1", "k2"),
+            row("p1", "k1", "sv1", "v1"),
+            row("p1", "k2", "sv1", "v2")
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE p=? AND c IN (?, ?) ORDER BY c DESC", "p1", "k1", "k2"),
+            row("p1", "k2", "sv1", "v2"),
+            row("p1", "k1", "sv1", "v1")
+        );
+    }
+
+    /**
+     * Check query with KEY IN clause
+     * migrated from cql_tests.py:TestCQL.select_key_in_test()
+     */
+    @Test
+    public void testSelectKeyIn() throws Throwable
+    {
+        createTable("CREATE TABLE %s (userid uuid PRIMARY KEY, firstname text, lastname text, age int)");
+
+        UUID id1 = UUID.fromString("550e8400-e29b-41d4-a716-446655440000");
+        UUID id2 = UUID.fromString("f47ac10b-58cc-4372-a567-0e02b2c3d479");
+
+        execute("INSERT INTO %s (userid, firstname, lastname, age) VALUES (?, 'Frodo', 'Baggins', 32)", id1);
+        execute("INSERT INTO %s (userid, firstname, lastname, age) VALUES (?, 'Samwise', 'Gamgee', 33)", id2);
+
+        assertRowCount(execute("SELECT firstname, lastname FROM %s WHERE userid IN (?, ?)", id1, id2), 2);
+    }
+
+    /**
+     * Check query with KEY IN clause for wide row tables
+     * migrated from cql_tests.py:TestCQL.in_clause_wide_rows_test()
+     */
+    @Test
+    public void testSelectKeyInForWideRows() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v int, PRIMARY KEY (k, c)) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s (k, c, v) VALUES (0, ?, ?)", i, i);
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c IN (5, 2, 8)"),
+                   row(2), row(5), row(8));
+
+        createTable("CREATE TABLE %s (k int, c1 int, c2 int, v int, PRIMARY KEY (k, c1, c2)) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s (k, c1, c2, v) VALUES (0, 0, ?, ?)", i, i);
+
+        assertInvalid("SELECT v FROM %s WHERE k = 0 AND c1 IN (5, 2, 8) AND c2 = 3");
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c1 = 0 AND c2 IN (5, 2, 8)"),
+                   row(2), row(5), row(8));
+    }
+
+    /**
+     * Check SELECT respects inclusive and exclusive bounds
+     * migrated from cql_tests.py:TestCQL.exclusive_slice_test()
+     */
+    @Test
+    public void testSelectBounds() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v int, PRIMARY KEY (k, c)) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s (k, c, v) VALUES (0, ?, ?)", i, i);
+
+        assertRowCount(execute("SELECT v FROM %s WHERE k = 0"), 10);
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c >= 2 AND c <= 6"),
+                   row(2), row(3), row(4), row(5), row(6));
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c > 2 AND c <= 6"),
+                   row(3), row(4), row(5), row(6));
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c >= 2 AND c < 6"),
+                   row(2), row(3), row(4), row(5));
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c > 2 AND c < 6"),
+                   row(3), row(4), row(5));
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c > 2 AND c <= 6 LIMIT 2"),
+                   row(3), row(4));
+
+        assertRows(execute("SELECT v FROM %s WHERE k = 0 AND c >= 2 AND c < 6 ORDER BY c DESC LIMIT 2"),
+                   row(5), row(4));
+    }
+
+    @Test
+    public void testSetContains() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories set<text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(categories)");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, set("lmn"));
+
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "xyz", "lmn"));
+
+        assertRows(execute("SELECT * FROM %s WHERE categories CONTAINS ?", "lmn"),
+                   row("test", 5, set("lmn"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "test", "lmn"),
+                   row("test", 5, set("lmn"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ?", "test", 5, "lmn"),
+                   row("test", 5, set("lmn"))
+        );
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ? AND categories CONTAINS ?", "xyz", "lmn", "notPresent");
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ? AND categories CONTAINS ? ALLOW FILTERING", "xyz", "lmn", "notPresent"));
+    }
+
+    @Test
+    public void testListContains() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories list<text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(categories)");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, list("lmn"));
+
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "xyz", "lmn"));
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?;", "test", "lmn"),
+                   row("test", 5, list("lmn"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE categories CONTAINS ?", "lmn"),
+                   row("test", 5, list("lmn"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ?;", "test", 5, "lmn"),
+                   row("test", 5, list("lmn"))
+        );
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ? AND categories CONTAINS ?",
+                      "test", 5, "lmn", "notPresent");
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ? AND categories CONTAINS ? ALLOW FILTERING",
+                            "test", 5, "lmn", "notPresent"));
+    }
+
+    @Test
+    public void testListContainsWithFiltering() throws Throwable
+    {
+        createTable("CREATE TABLE %s (e int PRIMARY KEY, f list<text>, s int)");
+        createIndex("CREATE INDEX ON %s(f)");
+        for(int i = 0; i < 3; i++)
+        {
+            execute("INSERT INTO %s (e, f, s) VALUES (?, ?, ?)", i, list("Dubai"), 4);
+        }
+        for(int i = 3; i < 5; i++)
+        {
+            execute("INSERT INTO %s (e, f, s) VALUES (?, ?, ?)", i, list("Dubai"), 3);
+        }
+        assertRows(execute("SELECT * FROM %s WHERE f CONTAINS ? AND s=? allow filtering", "Dubai", 3),
+                   row(4, list("Dubai"), 3),
+                   row(3, list("Dubai"), 3));
+    }
+
+    @Test
+    public void testMapKeyContains() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories map<text,text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(keys(categories))");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, map("lmn", "foo"));
+
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ?", "xyz", "lmn"));
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ?", "test", "lmn"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+        assertRows(execute("SELECT * FROM %s WHERE categories CONTAINS KEY ?", "lmn"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS KEY ?", "test", 5, "lmn"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS KEY ? AND categories CONTAINS KEY ?",
+                      "test", 5, "lmn", "notPresent");
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS KEY ? AND categories CONTAINS KEY ? ALLOW FILTERING",
+                            "test", 5, "lmn", "notPresent"));
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS KEY ? AND categories CONTAINS ?",
+                      "test", 5, "lmn", "foo");
+    }
+
+    @Test
+    public void testMapValueContains() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories map<text,text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(categories)");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, map("lmn", "foo"));
+
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "xyz", "foo"));
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "test", "foo"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE categories CONTAINS ?", "foo"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ?", "test", 5, "foo"),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ? AND categories CONTAINS ?"
+                     , "test", 5, "foo", "notPresent");
+
+        assertEmpty(execute("SELECT * FROM %s WHERE account = ? AND id = ? AND categories CONTAINS ? AND categories CONTAINS ? ALLOW FILTERING"
+                           , "test", 5, "foo", "notPresent"));
+    }
+
+    // See CASSANDRA-7525
+    @Test
+    public void testQueryMultipleIndexTypes() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories map<text,text>, PRIMARY KEY (account, id))");
+
+        // create an index on
+        createIndex("CREATE INDEX id_index ON %s(id)");
+        createIndex("CREATE INDEX categories_values_index ON %s(categories)");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, map("lmn", "foo"));
+
+        assertRows(execute("SELECT * FROM %s WHERE categories CONTAINS ? AND id = ? ALLOW FILTERING", "foo", 5),
+                   row("test", 5, map("lmn", "foo"))
+        );
+
+        assertRows(
+                  execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ? AND id = ? ALLOW FILTERING", "test", "foo", 5),
+                  row("test", 5, map("lmn", "foo"))
+        );
+    }
+
+    // See CASSANDRA-8033
+    @Test
+    public void testFilterForContains() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k1 int, k2 int, v set<int>, PRIMARY KEY ((k1, k2)))");
+        createIndex("CREATE INDEX ON %s(k2)");
+
+        execute("INSERT INTO %s (k1, k2, v) VALUES (?, ?, ?)", 0, 0, set(1, 2, 3));
+        execute("INSERT INTO %s (k1, k2, v) VALUES (?, ?, ?)", 0, 1, set(2, 3, 4));
+        execute("INSERT INTO %s (k1, k2, v) VALUES (?, ?, ?)", 1, 0, set(3, 4, 5));
+        execute("INSERT INTO %s (k1, k2, v) VALUES (?, ?, ?)", 1, 1, set(4, 5, 6));
+
+        assertRows(execute("SELECT * FROM %s WHERE k2 = ?", 1),
+                   row(0, 1, set(2, 3, 4)),
+                   row(1, 1, set(4, 5, 6))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE k2 = ? AND v CONTAINS ? ALLOW FILTERING", 1, 6),
+                   row(1, 1, set(4, 5, 6))
+        );
+
+        assertEmpty(execute("SELECT * FROM %s WHERE k2 = ? AND v CONTAINS ? ALLOW FILTERING", 1, 7));
+    }
+
+    // See CASSANDRA-8073
+    @Test
+    public void testIndexLookupWithClusteringPrefix() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b int, c int, d set<int>, PRIMARY KEY (a, b, c))");
+        createIndex("CREATE INDEX ON %s(d)");
+        execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, 0, set(1, 2, 3));
+        execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, 1, set(3, 4, 5));
+        execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, 0, set(1, 2, 3));
+        execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, 1, set(3, 4, 5));
+
+        assertRows(execute("SELECT * FROM %s WHERE a=? AND b=? AND d CONTAINS ?", 0, 1, 3),
+                   row(0, 1, 0, set(1, 2, 3)),
+                   row(0, 1, 1, set(3, 4, 5))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE a=? AND b=? AND d CONTAINS ?", 0, 1, 2),
+                   row(0, 1, 0, set(1, 2, 3))
+        );
+
+        assertRows(execute("SELECT * FROM %s WHERE a=? AND b=? AND d CONTAINS ?", 0, 1, 5),
+                   row(0, 1, 1, set(3, 4, 5))
+        );
+    }
+
+    @Test
+    public void testContainsKeyAndContainsWithIndexOnMapKey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories map<text,text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(keys(categories))");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, map("lmn", "foo"));
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 6, map("lmn", "foo2"));
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "test", "foo");
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ?", "test", "lmn"),
+                   row("test", 5, map("lmn", "foo")),
+                   row("test", 6, map("lmn", "foo2")));
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ? AND categories CONTAINS ? ALLOW FILTERING",
+                           "test", "lmn", "foo"),
+                   row("test", 5, map("lmn", "foo")));
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ? AND categories CONTAINS KEY ? ALLOW FILTERING",
+                           "test", "foo", "lmn"),
+                   row("test", 5, map("lmn", "foo")));
+    }
+
+    @Test
+    public void testContainsKeyAndContainsWithIndexOnMapValue() throws Throwable
+    {
+        createTable("CREATE TABLE %s (account text, id int, categories map<text,text>, PRIMARY KEY (account, id))");
+        createIndex("CREATE INDEX ON %s(categories)");
+
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 5, map("lmn", "foo"));
+        execute("INSERT INTO %s (account, id , categories) VALUES (?, ?, ?)", "test", 6, map("lmn2", "foo"));
+
+        assertInvalid("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ?", "test", "lmn");
+
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ?", "test", "foo"),
+                   row("test", 5, map("lmn", "foo")),
+                   row("test", 6, map("lmn2", "foo")));
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS KEY ? AND categories CONTAINS ? ALLOW FILTERING",
+                           "test", "lmn", "foo"),
+                   row("test", 5, map("lmn", "foo")));
+        assertRows(execute("SELECT * FROM %s WHERE account = ? AND categories CONTAINS ? AND categories CONTAINS KEY ? ALLOW FILTERING",
+                           "test", "foo", "lmn"),
+                   row("test", 5, map("lmn", "foo")));
+    }
+
+    /**
+     * Test token ranges
+     * migrated from cql_tests.py:TestCQL.token_range_test()
+     */
+    @Test
+    public void testTokenRange() throws Throwable
+    {
+        createTable(" CREATE TABLE %s (k int PRIMARY KEY, c int, v int)");
+
+        int c = 100;
+        for (int i = 0; i < c; i++)
+            execute("INSERT INTO %s (k, c, v) VALUES (?, ?, ?)", i, i, i);
+
+        Object[][] res = getRows(execute("SELECT k FROM %s"));
+        assertEquals(c, res.length);
+
+        Object[] inOrder = new Object[res.length];
+        for (int i = 0; i < res.length; i++)
+            inOrder[i] = res[i][0];
+
+        Long min_token = Long.MIN_VALUE;
+
+        res = getRows(execute(String.format("SELECT k FROM %s.%s WHERE token(k) >= %d",
+                                            keyspace(), currentTable(), min_token)));
+        assertEquals(c, res.length);
+
+        res = getRows(execute(String.format("SELECT k FROM %s.%s WHERE token(k) >= token(%d) AND token(k) < token(%d)",
+                                            keyspace(), currentTable(), inOrder[32], inOrder[65])));
+
+        for (int i = 32; i < 65; i++)
+            Assert.assertEquals(inOrder[i], res[i - 32][0]);
+    }
+
+    /**
+     * Test select count
+     * migrated from cql_tests.py:TestCQL.count_test()
+     */
+    @Test
+    public void testSelectCount() throws Throwable
+    {
+        createTable(" CREATE TABLE %s (kind text, time int, value1 int, value2 int, PRIMARY KEY(kind, time))");
+
+        execute("INSERT INTO %s (kind, time, value1, value2) VALUES ('ev1', ?, ?, ?)", 0, 0, 0);
+        execute("INSERT INTO %s (kind, time, value1, value2) VALUES ('ev1', ?, ?, ?)", 1, 1, 1);
+        execute("INSERT INTO %s (kind, time, value1) VALUES ('ev1', ?, ?)", 2, 2);
+        execute("INSERT INTO %s (kind, time, value1, value2) VALUES ('ev1', ?, ?, ?)", 3, 3, 3);
+        execute("INSERT INTO %s (kind, time, value1) VALUES ('ev1', ?, ?)", 4, 4);
+        execute("INSERT INTO %s (kind, time, value1, value2) VALUES ('ev2', 0, 0, 0)");
+
+        assertRows(execute("SELECT COUNT(*) FROM %s WHERE kind = 'ev1'"),
+                   row(5L));
+
+        assertRows(execute("SELECT COUNT(1) FROM %s WHERE kind IN ('ev1', 'ev2') AND time=0"),
+                   row(2L));
+    }
+
+    /**
+     * Range test query from #4372
+     * migrated from cql_tests.py:TestCQL.range_query_test()
+     */
+    @Test
+    public void testRangeQuery() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b int, c int, d int, e int, f text, PRIMARY KEY (a, b, c, d, e) )");
+
+        execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (1, 1, 1, 1, 2, '2')");
+        execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (1, 1, 1, 1, 1, '1')");
+        execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (1, 1, 1, 2, 1, '1')");
+        execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (1, 1, 1, 1, 3, '3')");
+        execute("INSERT INTO %s (a, b, c, d, e, f) VALUES (1, 1, 1, 1, 5, '5')");
+
+        assertRows(execute("SELECT a, b, c, d, e, f FROM %s WHERE a = 1 AND b = 1 AND c = 1 AND d = 1 AND e >= 2"),
+                   row(1, 1, 1, 1, 2, "2"),
+                   row(1, 1, 1, 1, 3, "3"),
+                   row(1, 1, 1, 1, 5, "5"));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.composite_row_key_test()
+     */
+    @Test
+    public void testCompositeRowKey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k1 int, k2 int, c int, v int, PRIMARY KEY ((k1, k2), c))");
+
+        for (int i = 0; i < 4; i++)
+            execute("INSERT INTO %s (k1, k2, c, v) VALUES (?, ?, ?, ?)", 0, i, i, i);
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row(0, 2, 2, 2),
+                   row(0, 3, 3, 3),
+                   row(0, 0, 0, 0),
+                   row(0, 1, 1, 1));
+
+        assertRows(execute("SELECT * FROM %s WHERE k1 = 0 and k2 IN (1, 3)"),
+                   row(0, 1, 1, 1),
+                   row(0, 3, 3, 3));
+
+        assertInvalid("SELECT * FROM %s WHERE k2 = 3");
+
+        assertRows(execute("SELECT * FROM %s WHERE token(k1, k2) = token(0, 1)"),
+                   row(0, 1, 1, 1));
+
+
+        assertRows(execute("SELECT * FROM %s WHERE token(k1, k2) > ?", Long.MIN_VALUE),
+                   row(0, 2, 2, 2),
+                   row(0, 3, 3, 3),
+                   row(0, 0, 0, 0),
+                   row(0, 1, 1, 1));
+    }
+
+    /**
+     * Test for #4532, NPE when trying to select a slice from a composite table
+     * migrated from cql_tests.py:TestCQL.bug_4532_test()
+     */
+    @Test
+    public void testSelectSliceFromComposite() throws Throwable
+    {
+        createTable("CREATE TABLE %s (status ascii, ctime bigint, key ascii, nil ascii, PRIMARY KEY (status, ctime, key))");
+
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345678,'key1','')");
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345678,'key2','')");
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345679,'key3','')");
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345679,'key4','')");
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345679,'key5','')");
+        execute("INSERT INTO %s (status,ctime,key,nil) VALUES ('C',12345680,'key6','')");
+
+        assertInvalid("SELECT * FROM %s WHERE ctime>=12345679 AND key='key3' AND ctime<=12345680 LIMIT 3;");
+        assertInvalid("SELECT * FROM %s WHERE ctime=12345679  AND key='key3' AND ctime<=12345680 LIMIT 3");
+    }
+
+    /**
+     * Test for #4716 bug and more generally for good behavior of ordering,
+     * migrated from cql_tests.py:TestCQL.reversed_compact_test()
+     */
+    @Test
+    public void testReverseCompact() throws Throwable
+    {
+        createTable("CREATE TABLE %s ( k text, c int, v int, PRIMARY KEY (k, c) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY (c DESC)");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s (k, c, v) VALUES ('foo', ?, ?)", i, i);
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo'"),
+                   row(5), row(4), row(3));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo'"),
+                   row(6), row(5), row(4), row(3), row(2));
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo' ORDER BY c ASC"),
+                   row(3), row(4), row(5));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo' ORDER BY c ASC"),
+                   row(2), row(3), row(4), row(5), row(6));
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo' ORDER BY c DESC"),
+                   row(5), row(4), row(3));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo' ORDER BY c DESC"),
+                   row(6), row(5), row(4), row(3), row(2));
+
+        createTable("CREATE TABLE %s ( k text, c int, v int, PRIMARY KEY (k, c) ) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s(k, c, v) VALUES ('foo', ?, ?)", i, i);
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo'"),
+                   row(3), row(4), row(5));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo'"),
+                   row(2), row(3), row(4), row(5), row(6));
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo' ORDER BY c ASC"),
+                   row(3), row(4), row(5));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo' ORDER BY c ASC"),
+                   row(2), row(3), row(4), row(5), row(6));
+
+        assertRows(execute("SELECT c FROM %s WHERE c > 2 AND c < 6 AND k = 'foo' ORDER BY c DESC"),
+                   row(5), row(4), row(3));
+
+        assertRows(execute("SELECT c FROM %s WHERE c >= 2 AND c <= 6 AND k = 'foo' ORDER BY c DESC"),
+                   row(6), row(5), row(4), row(3), row(2));
+    }
+
+    /**
+     * Test for the bug from #4760 and #4759,
+     * migrated from cql_tests.py:TestCQL.reversed_compact_multikey_test()
+     */
+    @Test
+    public void testReversedCompactMultikey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key text, c1 int, c2 int, value text, PRIMARY KEY(key, c1, c2) ) WITH COMPACT STORAGE AND CLUSTERING ORDER BY(c1 DESC, c2 DESC)");
+
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 3; j++)
+                execute("INSERT INTO %s (key, c1, c2, value) VALUES ('foo', ?, ?, 'bar')", i, j);
+
+        // Equalities
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 = 1"),
+                   row(1, 2), row(1, 1), row(1, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 = 1 ORDER BY c1 ASC, c2 ASC"),
+                   row(1, 0), row(1, 1), row(1, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 = 1 ORDER BY c1 DESC, c2 DESC"),
+                   row(1, 2), row(1, 1), row(1, 0));
+
+        // GT
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 > 1"),
+                   row(2, 2), row(2, 1), row(2, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 > 1 ORDER BY c1 ASC, c2 ASC"),
+                   row(2, 0), row(2, 1), row(2, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 > 1 ORDER BY c1 DESC, c2 DESC"),
+                   row(2, 2), row(2, 1), row(2, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 >= 1"),
+                   row(2, 2), row(2, 1), row(2, 0), row(1, 2), row(1, 1), row(1, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 >= 1 ORDER BY c1 ASC, c2 ASC"),
+                   row(1, 0), row(1, 1), row(1, 2), row(2, 0), row(2, 1), row(2, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 >= 1 ORDER BY c1 ASC"),
+                   row(1, 0), row(1, 1), row(1, 2), row(2, 0), row(2, 1), row(2, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 >= 1 ORDER BY c1 DESC, c2 DESC"),
+                   row(2, 2), row(2, 1), row(2, 0), row(1, 2), row(1, 1), row(1, 0));
+
+        // LT
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 < 1"),
+                   row(0, 2), row(0, 1), row(0, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 < 1 ORDER BY c1 ASC, c2 ASC"),
+                   row(0, 0), row(0, 1), row(0, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 < 1 ORDER BY c1 DESC, c2 DESC"),
+                   row(0, 2), row(0, 1), row(0, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 <= 1"),
+                   row(1, 2), row(1, 1), row(1, 0), row(0, 2), row(0, 1), row(0, 0));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 <= 1 ORDER BY c1 ASC, c2 ASC"),
+                   row(0, 0), row(0, 1), row(0, 2), row(1, 0), row(1, 1), row(1, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 <= 1 ORDER BY c1 ASC"),
+                   row(0, 0), row(0, 1), row(0, 2), row(1, 0), row(1, 1), row(1, 2));
+
+        assertRows(execute("SELECT c1, c2 FROM %s WHERE key='foo' AND c1 <= 1 ORDER BY c1 DESC, c2 DESC"),
+                   row(1, 2), row(1, 1), row(1, 0), row(0, 2), row(0, 1), row(0, 0));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.bug_4882_test()
+     */
+    @Test
+    public void testDifferentOrdering() throws Throwable
+    {
+        createTable(" CREATE TABLE %s ( k int, c1 int, c2 int, v int, PRIMARY KEY (k, c1, c2) ) WITH CLUSTERING ORDER BY (c1 ASC, c2 DESC)");
+
+        execute("INSERT INTO %s (k, c1, c2, v) VALUES (0, 0, 0, 0)");
+        execute("INSERT INTO %s (k, c1, c2, v) VALUES (0, 1, 1, 1)");
+        execute("INSERT INTO %s (k, c1, c2, v) VALUES (0, 0, 2, 2)");
+        execute("INSERT INTO %s (k, c1, c2, v) VALUES (0, 1, 3, 3)");
+
+        assertRows(execute("select * from %s where k = 0 limit 1"),
+                   row(0, 0, 2, 2));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.allow_filtering_test()
+     */
+    @Test
+    public void testAllowFiltering() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v int, PRIMARY KEY (k, c))");
+
+        for (int i = 0; i < 3; i++)
+            for (int j = 0; j < 3; j++)
+                execute("INSERT INTO %s (k, c, v) VALUES (?, ?, ?)", i, j, j);
+
+        // Don't require filtering, always allowed
+        String[] queries = new String[]
+                           {
+                           "SELECT * FROM %s WHERE k = 1",
+                           "SELECT * FROM %s WHERE k = 1 AND c > 2",
+                           "SELECT * FROM %s WHERE k = 1 AND c = 2"
+                           };
+
+        for (String q : queries)
+        {
+            execute(q);
+            execute(q + " ALLOW FILTERING");
+        }
+
+        // Require filtering, allowed only with ALLOW FILTERING
+        queries = new String[]
+                  {
+                  "SELECT * FROM %s WHERE c = 2",
+                  "SELECT * FROM %s WHERE c > 2 AND c <= 4"
+                  };
+
+        for (String q : queries)
+        {
+            assertInvalid(q);
+            execute(q + " ALLOW FILTERING");
+        }
+
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, a int, b int,)");
+        createIndex("CREATE INDEX ON %s (a)");
+
+        for (int i = 0; i < 5; i++)
+            execute("INSERT INTO %s (k, a, b) VALUES (?, ?, ?)", i, i * 10, i * 100);
+
+        // Don't require filtering, always allowed
+        queries = new String[]
+                  {
+                  "SELECT * FROM %s WHERE k = 1",
+                  "SELECT * FROM %s WHERE a = 20"
+                  };
+
+        for (String q : queries)
+        {
+            execute(q);
+            execute(q + " ALLOW FILTERING");
+        }
+
+        // Require filtering, allowed only with ALLOW FILTERING
+        queries = new String[]
+                  {
+                  "SELECT * FROM %s WHERE a = 20 AND b = 200"
+                  };
+
+        for (String q : queries)
+        {
+            assertInvalid(q);
+            execute(q + " ALLOW FILTERING");
+        }
+    }
+
+    /**
+     * Test for bug from #5122,
+     * migrated from cql_tests.py:TestCQL.composite_partition_key_validation_test()
+     */
+    @Test
+    public void testSelectOnCompositeInvalid() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b text, c uuid, PRIMARY KEY ((a, b)))");
+
+        execute("INSERT INTO %s (a, b , c ) VALUES (1, 'aze', 4d481800-4c5f-11e1-82e0-3f484de45426)");
+        execute("INSERT INTO %s (a, b , c ) VALUES (1, 'ert', 693f5800-8acb-11e3-82e0-3f484de45426)");
+        execute("INSERT INTO %s (a, b , c ) VALUES (1, 'opl', d4815800-2d8d-11e0-82e0-3f484de45426)");
+
+        assertRowCount(execute("SELECT * FROM %s"), 3);
+        assertInvalid("SELECT * FROM %s WHERE a=1");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.multi_in_compact_non_composite_test()
+     */
+    @Test
+    public void testMultiSelectsNonCompositeCompactStorage() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key int, c int, v int, PRIMARY KEY (key, c)) WITH COMPACT STORAGE");
+
+        execute("INSERT INTO %s (key, c, v) VALUES (0, 0, 0)");
+        execute("INSERT INTO %s (key, c, v) VALUES (0, 1, 1)");
+        execute("INSERT INTO %s (key, c, v) VALUES (0, 2, 2)");
+
+        assertRows(execute("SELECT * FROM %s WHERE key=0 AND c IN (0, 2)"),
+                   row(0, 0, 0), row(0, 2, 2));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.ticket_5230_test()
+     */
+    @Test
+    public void testMultipleClausesOnPrimaryKey() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key text, c text, v text, PRIMARY KEY(key, c))");
+
+        execute("INSERT INTO %s (key, c, v) VALUES ('foo', '1', '1')");
+        execute("INSERT INTO %s(key, c, v) VALUES ('foo', '2', '2')");
+        execute("INSERT INTO %s(key, c, v) VALUES ('foo', '3', '3')");
+
+        assertRows(execute("SELECT c FROM %s WHERE key = 'foo' AND c IN ('1', '2')"),
+                   row("1"), row("2"));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.bug_5404()
+     */
+    @Test
+    public void testSelectWithToken() throws Throwable
+    {
+        createTable("CREATE TABLE %s (key text PRIMARY KEY)");
+
+        // We just want to make sure this doesn 't NPE server side
+        assertInvalid("select * from %s where token(key) > token(int(3030343330393233)) limit 1");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.clustering_order_and_functions_test()
+     */
+    @Test
+    public void testFunctionsWithClusteringDesc() throws Throwable
+    {
+        createTable("CREATE TABLE %s ( k int, t timeuuid, PRIMARY KEY (k, t) ) WITH CLUSTERING ORDER BY (t DESC)");
+
+        for (int i = 0; i < 5; i++)
+            execute("INSERT INTO %s (k, t) VALUES (?, now())", i);
+
+        execute("SELECT dateOf(t) FROM %s");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.select_with_alias_test()
+     */
+    @Test
+    public void testSelectWithAlias() throws Throwable
+    {
+        createTable("CREATE TABLE %s (id int PRIMARY KEY, name text)");
+
+        for (int id = 0; id < 5; id++)
+            execute("INSERT INTO %s (id, name) VALUES (?, ?) USING TTL 10 AND TIMESTAMP 0", id, "name" + id);
+
+        // test aliasing count( *)
+        UntypedResultSet rs = execute("SELECT count(*) AS user_count FROM %s");
+        assertEquals("user_count", rs.metadata().get(0).name.toString());
+        assertEquals(5L, rs.one().getLong(rs.metadata().get(0).name.toString()));
+
+        // test aliasing regular value
+        rs = execute("SELECT name AS user_name FROM %s WHERE id = 0");
+        assertEquals("user_name", rs.metadata().get(0).name.toString());
+        assertEquals("name0", rs.one().getString(rs.metadata().get(0).name.toString()));
+
+        // test aliasing writetime
+        rs = execute("SELECT writeTime(name) AS name_writetime FROM %s WHERE id = 0");
+        assertEquals("name_writetime", rs.metadata().get(0).name.toString());
+        assertEquals(0, rs.one().getInt(rs.metadata().get(0).name.toString()));
+
+        // test aliasing ttl
+        rs = execute("SELECT ttl(name) AS name_ttl FROM %s WHERE id = 0");
+        assertEquals("name_ttl", rs.metadata().get(0).name.toString());
+        int ttl = rs.one().getInt(rs.metadata().get(0).name.toString());
+        assertTrue(ttl == 9 || ttl == 10);
+
+        // test aliasing a regular function
+        rs = execute("SELECT intAsBlob(id) AS id_blob FROM %s WHERE id = 0");
+        assertEquals("id_blob", rs.metadata().get(0).name.toString());
+        assertEquals(ByteBuffer.wrap(new byte[4]), rs.one().getBlob(rs.metadata().get(0).name.toString()));
+
+        // test that select throws a meaningful exception for aliases in where clause
+        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");
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.select_distinct_test()
+     */
+    @Test
+    public void testSelectDistinct() throws Throwable
+    {
+        // Test a regular(CQL3) table.
+        createTable("CREATE TABLE %s (pk0 int, pk1 int, ck0 int, val int, PRIMARY KEY((pk0, pk1), ck0))");
+
+        for (int i = 0; i < 3; i++)
+        {
+            execute("INSERT INTO %s (pk0, pk1, ck0, val) VALUES (?, ?, 0, 0)", i, i);
+            execute("INSERT INTO %s (pk0, pk1, ck0, val) VALUES (?, ?, 1, 1)", i, i);
+        }
+
+        assertRows(execute("SELECT DISTINCT pk0, pk1 FROM %s LIMIT 1"),
+                   row(0, 0));
+
+        assertRows(execute("SELECT DISTINCT pk0, pk1 FROM %s LIMIT 3"),
+                   row(0, 0),
+                   row(2, 2),
+                   row(1, 1));
+
+        // Test selection validation.
+        assertInvalidMessage("queries must request all the partition key columns", "SELECT DISTINCT pk0 FROM %s");
+        assertInvalidMessage("queries must only request partition key columns", "SELECT DISTINCT pk0, pk1, ck0 FROM %s");
+
+        //Test a 'compact storage' table.
+        createTable("CREATE TABLE %s (pk0 int, pk1 int, val int, PRIMARY KEY((pk0, pk1))) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 3; i++)
+            execute("INSERT INTO %s (pk0, pk1, val) VALUES (?, ?, ?)", i, i, i);
+
+        assertRows(execute("SELECT DISTINCT pk0, pk1 FROM %s LIMIT 1"),
+                   row(0, 0));
+
+        assertRows(execute("SELECT DISTINCT pk0, pk1 FROM %s LIMIT 3"),
+                   row(0, 0),
+                   row(2, 2),
+                   row(1, 1));
+
+        // Test a 'wide row' thrift table.
+        createTable("CREATE TABLE %s (pk int, name text, val int, PRIMARY KEY(pk, name)) WITH COMPACT STORAGE");
+
+        for (int i = 0; i < 3; i++)
+        {
+            execute("INSERT INTO %s (pk, name, val) VALUES (?, 'name0', 0)", i);
+            execute("INSERT INTO %s (pk, name, val) VALUES (?, 'name1', 1)", i);
+        }
+
+        assertRows(execute("SELECT DISTINCT pk FROM %s LIMIT 1"),
+                   row(1));
+
+        assertRows(execute("SELECT DISTINCT pk FROM %s LIMIT 3"),
+                   row(1),
+                   row(0),
+                   row(2));
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.select_distinct_with_deletions_test()
+     */
+    @Test
+    public void testSelectDistinctWithDeletions() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, c int, v int)");
+
+        for (int i = 0; i < 10; i++)
+            execute("INSERT INTO %s (k, c, v) VALUES (?, ?, ?)", i, i, i);
+
+        Object[][] rows = getRows(execute("SELECT DISTINCT k FROM %s"));
+        Assert.assertEquals(10, rows.length);
+        Object key_to_delete = rows[3][0];
+
+        execute("DELETE FROM %s WHERE k=?", key_to_delete);
+
+        rows = getRows(execute("SELECT DISTINCT k FROM %s"));
+        Assert.assertEquals(9, rows.length);
+
+        rows = getRows(execute("SELECT DISTINCT k FROM %s LIMIT 5"));
+        Assert.assertEquals(5, rows.length);
+
+        rows = getRows(execute("SELECT DISTINCT k FROM %s"));
+        Assert.assertEquals(9, rows.length);
+    }
+
+    /**
+     * Migrated from cql_tests.py:TestCQL.bug_6327_test()
+     */
+    @Test
+    public void testSelectInClauseAtOne() throws Throwable
+    {
+        createTable("CREATE TABLE %s ( k int, v int, PRIMARY KEY (k, v))");
+
+        execute("INSERT INTO %s (k, v) VALUES (0, 0)");
+
+        flush();
+
+        assertRows(execute("SELECT v FROM %s WHERE k=0 AND v IN (1, 0)"),
+                   row(0));
+    }
+
+    /**
+     * Test for the #6579 'select count' paging bug,
+     * migrated from cql_tests.py:TestCQL.select_count_paging_test()
+     */
+    @Test
+    public void testSelectCountPaging() throws Throwable
+    {
+        createTable("create table %s (field1 text, field2 timeuuid, field3 boolean, primary key(field1, field2))");
+        createIndex("create index test_index on %s (field3)");
+
+        execute("insert into %s (field1, field2, field3) values ('hola', now(), false)");
+        execute("insert into %s (field1, field2, field3) values ('hola', now(), false)");
+
+        assertRows(execute("select count(*) from %s where field3 = false limit 1"),
+                   row(1L));
+    }
+
+    /**
+     * Test for #7105 bug,
+     * migrated from cql_tests.py:TestCQL.clustering_order_in_test()
+     */
+    @Test
+    public void testClusteringOrder() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b int, c int, PRIMARY KEY ((a, b), c) ) with clustering order by (c desc)");
+
+        execute("INSERT INTO %s (a, b, c) VALUES (1, 2, 3)");
+        execute("INSERT INTO %s (a, b, c) VALUES (4, 5, 6)");
+
+        assertRows(execute("SELECT * FROM %s WHERE a=1 AND b=2 AND c IN (3)"),
+                   row(1, 2, 3));
+        assertRows(execute("SELECT * FROM %s WHERE a=1 AND b=2 AND c IN (3, 4)"),
+                   row(1, 2, 3));
+    }
+
+    /**
+     * Test for #7105 bug,
+     * SELECT with IN on final column of composite and compound primary key fails
+     * migrated from cql_tests.py:TestCQL.bug7105_test()
+     */
+    @Test
+    public void testSelectInFinalColumn() throws Throwable
+    {
+        createTable("CREATE TABLE %s (a int, b int, c int, d int, PRIMARY KEY (a, b))");
+
+        execute("INSERT INTO %s (a, b, c, d) VALUES (1, 2, 3, 3)");
+        execute("INSERT INTO %s (a, b, c, d) VALUES (1, 4, 6, 5)");
+
+        assertRows(execute("SELECT * FROM %s WHERE a=1 AND b=2 ORDER BY b DESC"),
+                   row(1, 2, 3, 3));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/test/unit/org/apache/cassandra/cql3/validation/operations/UpdateTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/operations/UpdateTest.java b/test/unit/org/apache/cassandra/cql3/validation/operations/UpdateTest.java
new file mode 100644
index 0000000..19855d8
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/UpdateTest.java
@@ -0,0 +1,59 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.cassandra.cql3.validation.operations;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQLTester;
+import org.apache.cassandra.utils.ByteBufferUtil;
+
+public class UpdateTest extends CQLTester
+{
+    /**
+     * Test altering the type of a column, including the one in the primary key (#4041)
+     * migrated from cql_tests.py:TestCQL.update_type_test()
+     */
+    @Test
+    public void testUpdateColumnType() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k text, c text, s set <text>, v text, PRIMARY KEY(k, c))");
+
+        // using utf8 character so that we can see the transition to BytesType
+        execute("INSERT INTO %s (k, c, v, s) VALUES ('ɸ', 'ɸ', 'ɸ', {'ɸ'})");
+
+        assertRows(execute("SELECT * FROM %s"),
+                   row("ɸ", "ɸ", set("ɸ"), "ɸ"));
+
+        execute("ALTER TABLE %s ALTER v TYPE blob");
+        assertRows(execute("SELECT * FROM %s"),
+                   row("ɸ", "ɸ", set("ɸ"), ByteBufferUtil.bytes("ɸ")));
+
+        execute("ALTER TABLE %s ALTER k TYPE blob");
+        assertRows(execute("SELECT * FROM %s"),
+                   row(ByteBufferUtil.bytes("ɸ"), "ɸ", set("ɸ"), ByteBufferUtil.bytes("ɸ")));
+
+        execute("ALTER TABLE %s ALTER c TYPE blob");
+        assertRows(execute("SELECT * FROM %s"),
+                   row(ByteBufferUtil.bytes("ɸ"), ByteBufferUtil.bytes("ɸ"), set("ɸ"), ByteBufferUtil.bytes("ɸ")));
+
+        execute("ALTER TABLE %s ALTER s TYPE set<blob>");
+        assertRows(execute("SELECT * FROM %s"),
+                   row(ByteBufferUtil.bytes("ɸ"), ByteBufferUtil.bytes("ɸ"), set(ByteBufferUtil.bytes("ɸ")), ByteBufferUtil.bytes("ɸ")));
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/test/unit/org/apache/cassandra/cql3/validation/operations/UseTest.java
----------------------------------------------------------------------
diff --git a/test/unit/org/apache/cassandra/cql3/validation/operations/UseTest.java b/test/unit/org/apache/cassandra/cql3/validation/operations/UseTest.java
new file mode 100644
index 0000000..e1498b6
--- /dev/null
+++ b/test/unit/org/apache/cassandra/cql3/validation/operations/UseTest.java
@@ -0,0 +1,31 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.cassandra.cql3.validation.operations;
+
+import org.junit.Test;
+
+import org.apache.cassandra.cql3.CQLTester;
+
+public class UseTest extends CQLTester
+{
+    @Test
+    public void testUseStatementWithBindVariable() throws Throwable
+    {
+        assertInvalidSyntaxMessage("Bind variables cannot be used for keyspace names", "USE ?");
+    }
+}

http://git-wip-us.apache.org/repos/asf/cassandra/blob/f797bfa4/tools/stress/src/org/apache/cassandra/stress/generate/values/TimeUUIDs.java
----------------------------------------------------------------------
diff --git a/tools/stress/src/org/apache/cassandra/stress/generate/values/TimeUUIDs.java b/tools/stress/src/org/apache/cassandra/stress/generate/values/TimeUUIDs.java
index 7bfabf5..537d54e 100644
--- a/tools/stress/src/org/apache/cassandra/stress/generate/values/TimeUUIDs.java
+++ b/tools/stress/src/org/apache/cassandra/stress/generate/values/TimeUUIDs.java
@@ -46,6 +46,6 @@ public class TimeUUIDs extends Generator<UUID>
     @Override
     public UUID generate()
     {
-        return UUIDGen.getTimeUUID(dateGen.generate().getTime(), clockSeqAndNode);
+        return UUIDGen.getTimeUUID(dateGen.generate().getTime(), 0L, clockSeqAndNode);
     }
 }


Mime
View raw message