/*
*
* 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.util.Arrays;
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.cql3.restrictions.StatementRestrictions;
import org.apache.cassandra.dht.ByteOrderedPartitioner;
/**
* SELECT statement tests that require a ByteOrderedPartitioner
*/
public class SelectOrderedPartitionerTest extends CQLTester
{
@BeforeClass
public static void setUp()
{
DatabaseDescriptor.setPartitionerUnsafe(ByteOrderedPartitioner.instance);
}
@Test
public void testTokenAndIndex() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, d int, PRIMARY KEY (a, b, c))");
createIndex("CREATE INDEX ON %s(c)");
for (int i = 0; i < 10; i++)
{
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i, i, i);
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i + 10, i + 10, i + 10);
}
beforeAndAfterFlush(() -> {
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(8) AND a = 9 AND c = 9 ALLOW FILTERING"),
row(9, 9, 9, 9));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(8) AND a > 8 AND c = 9 ALLOW FILTERING"),
row(9, 9, 9, 9));
});
}
@Test
public void testFilteringOnAllPartitionKeysWithTokenRestriction() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, d int, PRIMARY KEY ((a, b), c))");
for (int i = 0; i < 10; i++)
{
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i, i, i);
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i + 10, i + 10, i + 10);
}
assertEmpty(execute("SELECT * FROM %s WHERE token(a, b) > token(10, 10)"));
assertEmpty(execute("SELECT * FROM %s WHERE token(a, b) > token(10, 10) AND a < 8 AND b < 8 ALLOW FILTERING"));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(5, 5) AND a < 8 AND b < 8 ALLOW FILTERING"),
row(6, 6, 6, 6),
row(7, 7, 7, 7));
}
@Test
public void testFilteringOnPartitionKeyWithToken() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, d int, PRIMARY KEY ((a, b), c))");
createIndex("CREATE INDEX ON %s(d)");
for (int i = 0; i < 10; i++)
{
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i, i, i);
execute("INSERT INTO %s (a,b,c,d) VALUES (?, ?, ?, ?)", i, i + 10, i + 10, i + 10);
}
beforeAndAfterFlush(() -> {
assertRowsIgnoringOrder(execute("SELECT * FROM %s WHERE token(a, b) > token(5, 10) AND b < 8 ALLOW FILTERING"),
row(6, 6, 6, 6),
row(7, 7, 7, 7));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(8, 10) AND a = 9 ALLOW FILTERING"),
row(9, 9, 9, 9),
row(9, 19, 19, 19));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(8, 10) AND a = 9 AND d = 9 ALLOW FILTERING"),
row(9, 9, 9, 9));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(8, 10) AND a > 8 AND b > 8 AND d = 9 ALLOW FILTERING"),
row(9, 9, 9, 9));
assertRows(execute("SELECT * FROM %s WHERE a = 9 AND b = 9 AND token(a, b) > token(8, 10) AND d = 9 ALLOW FILTERING"),
row(9, 9, 9, 9));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(8, 10) AND a = 9 AND c = 19 ALLOW FILTERING"),
row(9, 19, 19, 19));
assertEmpty(execute("SELECT * FROM %s WHERE token(a, b) = token(8, 8) AND b = 9 ALLOW FILTERING"));
});
}
@Test
public void testTokenAndCollections() throws Throwable
{
createTable("CREATE TABLE %s (a frozen<map<int, int>>, b int, c int, PRIMARY KEY (a, b))");
for (int i = 0; i < 10; i++)
{
execute("INSERT INTO %s (a,b,c) VALUES (?, ?, ?)", map(i, i), i, i);
execute("INSERT INTO %s (a,b,c) VALUES (?, ?, ?)", map(i, i, 100, 200), i + 10, i + 10);
}
beforeAndAfterFlush(() -> {
assertRows(execute("SELECT * FROM %s WHERE token(a) > token({0: 0}) AND a CONTAINS KEY 9 ALLOW FILTERING"),
row(map(9, 9), 9, 9),
row(map(9, 9, 100, 200), 19, 19));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token({0: 0}) AND a CONTAINS KEY 9 AND a CONTAINS 200 ALLOW FILTERING"),
row(map(9, 9, 100, 200), 19, 19));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token({0: 0}) AND a CONTAINS KEY 9 AND b = 19 ALLOW FILTERING"),
row(map(9, 9, 100, 200), 19, 19));
});
}
@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");
assertInvalidMessage("The token() function must contains only partition key components",
"SELECT * FROM %s WHERE token(a, b) >= token(?, ?)", "b", 0);
assertInvalidMessage("More than one restriction was found for the start bound on a",
"SELECT * FROM %s WHERE token(a) >= token(?) and token(a) >= token(?)", 0, 1);
assertInvalidMessage("Columns \"a\" cannot be restricted by both an equality and an inequality relation",
"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);
assertInvalidMessage("More than one restriction was found for the start bound on a",
"SELECT * FROM %s WHERE token(a) > token(?) AND token(a) > token(?)", 1, 2);
assertInvalidMessage("More than one restriction was found for the end bound on a",
"SELECT * FROM %s WHERE token(a) <= token(?) AND token(a) < token(?)", 1, 2);
assertInvalidMessage("Columns \"a\" cannot be restricted by both an equality and an inequality relation",
"SELECT * FROM %s WHERE token(a) > token(?) AND token(a) = token(?)", 1, 2);
assertInvalidMessage("a cannot be restricted by more than one relation if it includes an Equal",
"SELECT * FROM %s WHERE token(a) = token(?) AND token(a) > token(?)", 1, 2);
}
@Test
public void testTokenFunctionWithPartitionKeyAndClusteringKeyArguments() throws Throwable
{
createTable("CREATE TABLE IF NOT EXISTS %s (a int, b text, PRIMARY KEY (a, b))");
assertInvalidMessage("The token() function must contains only partition key components",
"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"));
assertInvalidMessage("The token() function must be applied to all partition key components or none of them",
"SELECT * FROM %s WHERE token(a) > token(?) and token(b) > token(?)", 0, "a");
assertInvalidMessage("The token() function must be applied to all partition key components or none of them",
"SELECT * FROM %s WHERE token(a) > token(?, ?) and token(a) < token(?, ?) and token(b) > token(?, ?) ",
0, "a", 0, "d", 0, "a");
assertInvalidMessage("The token function arguments must be in the partition key order: a, b",
"SELECT * FROM %s WHERE token(b, a) > token(0, 'c')");
assertInvalidMessage("The token() function must be applied to all partition key components or none of them",
"SELECT * FROM %s WHERE token(a, b) > token(?, ?) and token(b) < token(?, ?)", 0, "a", 0, "a");
assertInvalidMessage("The token() function must be applied to all partition key components or none of them",
"SELECT * FROM %s WHERE token(a) > token(?, ?) and token(b) > token(?, ?)", 0, "a", 0, "a");
}
@Test
public void testSingleColumnPartitionKeyWithTokenNonTokenRestrictionsMix() throws Throwable
{
createTable("CREATE TABLE %s (a int primary key, b int)");
execute("INSERT INTO %s (a, b) VALUES (0, 0);");
execute("INSERT INTO %s (a, b) VALUES (1, 1);");
execute("INSERT INTO %s (a, b) VALUES (2, 2);");
execute("INSERT INTO %s (a, b) VALUES (3, 3);");
execute("INSERT INTO %s (a, b) VALUES (4, 4);");
assertRows(execute("SELECT * FROM %s WHERE a IN (?, ?);", 1, 3),
row(1, 1),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a)> token(?) and token(a) <= token(?);", 1, 3),
row(2, 2),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a)= token(2);"),
row(2, 2));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND token(a) <= token(?) AND a IN (?, ?);",
1, 3, 1, 3),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) < token(?) AND token(a) >= token(?) AND a IN (?, ?);",
1, 3, 1, 3),
row(3, 3));
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
"SELECT * FROM %s WHERE token(a) > token(?) AND token(a) <= token(?) AND a > ?;", 1, 3, 1);
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND token(a) <= token(?) AND a IN ?;",
1, 3, Arrays.asList(1, 3)),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND a = ?;", 1, 3),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE a = ? AND token(a) > token(?);", 3, 1),
row(3, 3));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) > token(?) AND a = ?;", 3, 1));
assertEmpty(execute("SELECT * FROM %s WHERE a = ? AND token(a) > token(?);", 1, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND a IN (?, ?);", 2, 1, 3),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND token(a) < token(?) AND a IN (?, ?) ;", 2, 5, 1, 3),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE a IN (?, ?) AND token(a) > token(?) AND token(a) < token(?);", 1, 3, 2, 5),
row(3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) > token(?) AND a IN (?, ?) AND token(a) < token(?);", 2, 1, 3, 5),
row(3, 3));
assertEmpty(execute("SELECT * FROM %s WHERE a IN (?, ?) AND token(a) > token(?);", 1, 3, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) <= token(?) AND a = ?;", 2, 2),
row(2, 2));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) <= token(?) AND a = ?;", 2, 3));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) = token(?) AND a = ?;", 2, 3));
assertRows(execute("SELECT * FROM %s WHERE token(a) >= token(?) AND token(a) <= token(?) AND a = ?;", 2, 2, 2),
row(2, 2));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) >= token(?) AND token(a) < token(?) AND a = ?;", 2, 2, 2));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) > token(?) AND token(a) <= token(?) AND a = ?;", 2, 2, 2));
assertEmpty(execute("SELECT * FROM %s WHERE token(a) > token(?) AND token(a) < token(?) AND a = ?;", 2, 2, 2));
}
@Test
public void testMultiColumnPartitionKeyWithTokenNonTokenRestrictionsMix() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, primary key((a, b)))");
execute("INSERT INTO %s (a, b, c) VALUES (0, 0, 0);");
execute("INSERT INTO %s (a, b, c) VALUES (0, 1, 1);");
execute("INSERT INTO %s (a, b, c) VALUES (0, 2, 2);");
execute("INSERT INTO %s (a, b, c) VALUES (1, 0, 3);");
execute("INSERT INTO %s (a, b, c) VALUES (1, 1, 4);");
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(?, ?);", 0, 0),
row(0, 1, 1),
row(0, 2, 2),
row(1, 0, 3),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(?, ?) AND a = ? AND b IN (?, ?);",
0, 0, 1, 0, 1),
row(1, 0, 3),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE a = ? AND token(a, b) > token(?, ?) AND b IN (?, ?);",
1, 0, 0, 0, 1),
row(1, 0, 3),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE b IN (?, ?) AND token(a, b) > token(?, ?) AND a = ?;",
0, 1, 0, 0, 1),
row(1, 0, 3),
row(1, 1, 4));
assertEmpty(execute("SELECT * FROM %s WHERE b IN (?, ?) AND token(a, b) > token(?, ?) AND token(a, b) < token(?, ?) AND a = ?;",
0, 1, 0, 0, 0, 0, 1));
assertEmpty(execute("SELECT * FROM %s WHERE b IN (?, ?) AND token(a, b) > token(?, ?) AND token(a, b) <= token(?, ?) AND a = ?;",
0, 1, 0, 0, 0, 0, 1));
assertEmpty(execute("SELECT * FROM %s WHERE b IN (?, ?) AND token(a, b) >= token(?, ?) AND token(a, b) < token(?, ?) AND a = ?;",
0, 1, 0, 0, 0, 0, 1));
assertEmpty(execute("SELECT * FROM %s WHERE b IN (?, ?) AND token(a, b) = token(?, ?) AND a = ?;",
0, 1, 0, 0, 1));
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
"SELECT * FROM %s WHERE token(a, b) > token(?, ?) AND a = ?;", 0, 0, 1);
}
@Test
public void testMultiColumnPartitionKeyWithIndexAndTokenNonTokenRestrictionsMix() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, primary key((a, b)))");
createIndex("CREATE INDEX ON %s(b)");
createIndex("CREATE INDEX ON %s(c)");
execute("INSERT INTO %s (a, b, c) VALUES (0, 0, 0);");
execute("INSERT INTO %s (a, b, c) VALUES (0, 1, 1);");
execute("INSERT INTO %s (a, b, c) VALUES (0, 2, 2);");
execute("INSERT INTO %s (a, b, c) VALUES (1, 0, 3);");
execute("INSERT INTO %s (a, b, c) VALUES (1, 1, 4);");
assertRows(execute("SELECT * FROM %s WHERE b = ?;", 1),
row(0, 1, 1),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE token(a, b) > token(?, ?) AND b = ?;", 0, 0, 1),
row(0, 1, 1),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE b = ? AND token(a, b) > token(?, ?);", 1, 0, 0),
row(0, 1, 1),
row(1, 1, 4));
assertRows(execute("SELECT * FROM %s WHERE b = ? AND token(a, b) > token(?, ?) and c = ? ALLOW FILTERING;", 1, 0, 0, 4),
row(1, 1, 4));
}
@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'");
assertInvalid("SELECT blog_id, content FROM %s WHERE time1 > 0 AND author='foo'");
assertInvalid("SELECT blog_id, content FROM %s WHERE time1 = 1 AND author='foo'");
assertInvalid("SELECT blog_id, content FROM %s WHERE time1 = 1 AND time2 = 0 AND author='foo'");
assertInvalid("SELECT content FROM %s WHERE time1 = 1 AND time2 = 1 AND author='foo'");
assertInvalid("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 = { 'keys': 'ALL', 'rows_per_partition': '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");
}
@Test
public void testTokenFunctionWithInvalidColumnNames() throws Throwable
{
createTable("CREATE TABLE %s (a int, b int, c int, d int, PRIMARY KEY ((a, b), c))");
assertInvalidMessage("Undefined column name e", "SELECT * FROM %s WHERE token(a, e) = token(0, 0)");
assertInvalidMessage("Undefined column name e", "SELECT * FROM %s WHERE token(a, e) > token(0, 1)");
assertInvalidMessage("Undefined column name e", "SELECT b AS e FROM %s WHERE token(a, e) = token(0, 0)");
assertInvalidMessage("Undefined column name e", "SELECT b AS e FROM %s WHERE token(a, e) > token(0, 1)");
}
}