| /* |
| * 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.entities; |
| |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.List; |
| |
| import org.apache.commons.lang3.StringUtils; |
| import org.junit.Assert; |
| import org.junit.BeforeClass; |
| import org.junit.Test; |
| |
| import org.apache.cassandra.cql3.CQLTester; |
| import org.apache.cassandra.cql3.restrictions.StatementRestrictions; |
| import org.apache.cassandra.db.marshal.*; |
| import org.apache.cassandra.dht.ByteOrderedPartitioner; |
| import org.apache.cassandra.exceptions.ConfigurationException; |
| import org.apache.cassandra.exceptions.InvalidRequestException; |
| import org.apache.cassandra.exceptions.SyntaxException; |
| import org.apache.cassandra.service.StorageService; |
| import org.apache.cassandra.utils.FBUtilities; |
| |
| import static org.junit.Assert.assertEquals; |
| |
| public class FrozenCollectionsTest extends CQLTester |
| { |
| @BeforeClass |
| public static void setUpClass() |
| { |
| // Selecting partitioner for a table is not exposed on CREATE TABLE. |
| StorageService.instance.setPartitionerUnsafe(ByteOrderedPartitioner.instance); |
| } |
| |
| @Test |
| public void testPartitionKeyUsage() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k frozen<set<int>> PRIMARY KEY, v int)"); |
| |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", set(), 1); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", set(1, 2, 3), 1); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", set(4, 5, 6), 0); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", set(7, 8, 9), 0); |
| |
| // overwrite with an update |
| execute("UPDATE %s SET v=? WHERE k=?", 0, set()); |
| execute("UPDATE %s SET v=? WHERE k=?", 0, set(1, 2, 3)); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(set(), 0), |
| row(set(1, 2, 3), 0), |
| row(set(4, 5, 6), 0), |
| row(set(7, 8, 9), 0) |
| ); |
| |
| assertRows(execute("SELECT k FROM %s"), |
| row(set()), |
| row(set(1, 2, 3)), |
| row(set(4, 5, 6)), |
| row(set(7, 8, 9)) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s LIMIT 2"), |
| row(set(), 0), |
| row(set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k=?", set(4, 5, 6)), |
| row(set(4, 5, 6), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k=?", set()), |
| row(set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k IN ?", list(set(4, 5, 6), set())), |
| row(set(), 0), |
| row(set(4, 5, 6), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE token(k) >= token(?)", set(4, 5, 6)), |
| row(set(4, 5, 6), 0), |
| row(set(7, 8, 9), 0) |
| ); |
| |
| assertInvalid("INSERT INTO %s (k, v) VALUES (null, 0)"); |
| |
| execute("DELETE FROM %s WHERE k=?", set()); |
| execute("DELETE FROM %s WHERE k=?", set(4, 5, 6)); |
| assertRows(execute("SELECT * FROM %s"), |
| row(set(1, 2, 3), 0), |
| row(set(7, 8, 9), 0) |
| ); |
| } |
| |
| @Test |
| public void testNestedPartitionKeyUsage() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k frozen<map<set<int>, list<int>>> PRIMARY KEY, v int)"); |
| |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", map(), 1); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", map(set(), list(1, 2, 3)), 0); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", map(set(1, 2, 3), list(1, 2, 3)), 1); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", map(set(4, 5, 6), list(1, 2, 3)), 0); |
| execute("INSERT INTO %s (k, v) VALUES (?, ?)", map(set(7, 8, 9), list(1, 2, 3)), 0); |
| |
| // overwrite with an update |
| execute("UPDATE %s SET v=? WHERE k=?", 0, map()); |
| execute("UPDATE %s SET v=? WHERE k=?", 0, map(set(1, 2, 3), list(1, 2, 3))); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(map(), 0), |
| row(map(set(), list(1, 2, 3)), 0), |
| row(map(set(1, 2, 3), list(1, 2, 3)), 0), |
| row(map(set(4, 5, 6), list(1, 2, 3)), 0), |
| row(map(set(7, 8, 9), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT k FROM %s"), |
| row(map()), |
| row(map(set(), list(1, 2, 3))), |
| row(map(set(1, 2, 3), list(1, 2, 3))), |
| row(map(set(4, 5, 6), list(1, 2, 3))), |
| row(map(set(7, 8, 9), list(1, 2, 3))) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s LIMIT 3"), |
| row(map(), 0), |
| row(map(set(), list(1, 2, 3)), 0), |
| row(map(set(1, 2, 3), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k=?", map(set(4, 5, 6), list(1, 2, 3))), |
| row(map(set(4, 5, 6), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k=?", map()), |
| row(map(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k=?", map(set(), list(1, 2, 3))), |
| row(map(set(), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k IN ?", list(map(set(4, 5, 6), list(1, 2, 3)), map(), map(set(), list(1, 2, 3)))), |
| row(map(), 0), |
| row(map(set(), list(1, 2, 3)), 0), |
| row(map(set(4, 5, 6), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE token(k) >= token(?)", map(set(4, 5, 6), list(1, 2, 3))), |
| row(map(set(4, 5, 6), list(1, 2, 3)), 0), |
| row(map(set(7, 8, 9), list(1, 2, 3)), 0) |
| ); |
| |
| execute("DELETE FROM %s WHERE k=?", map()); |
| execute("DELETE FROM %s WHERE k=?", map(set(), list(1, 2, 3))); |
| execute("DELETE FROM %s WHERE k=?", map(set(4, 5, 6), list(1, 2, 3))); |
| assertRows(execute("SELECT * FROM %s"), |
| row(map(set(1, 2, 3), list(1, 2, 3)), 0), |
| row(map(set(7, 8, 9), list(1, 2, 3)), 0) |
| ); |
| |
| } |
| |
| @Test |
| public void testClusteringKeyUsage() throws Throwable |
| { |
| for (String option : Arrays.asList("", " WITH COMPACT STORAGE")) |
| { |
| createTable("CREATE TABLE %s (a int, b frozen<set<int>>, c int, PRIMARY KEY (a, b))" + option); |
| |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, set(), 1); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, set(1, 2, 3), 1); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, set(4, 5, 6), 0); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, set(7, 8, 9), 0); |
| |
| // overwrite with an update |
| execute("UPDATE %s SET c=? WHERE a=? AND b=?", 0, 0, set()); |
| execute("UPDATE %s SET c=? WHERE a=? AND b=?", 0, 0, set(1, 2, 3)); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, set(), 0), |
| row(0, set(1, 2, 3), 0), |
| row(0, set(4, 5, 6), 0), |
| row(0, set(7, 8, 9), 0) |
| ); |
| |
| assertRows(execute("SELECT b FROM %s"), |
| row(set()), |
| row(set(1, 2, 3)), |
| row(set(4, 5, 6)), |
| row(set(7, 8, 9)) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s LIMIT 2"), |
| row(0, set(), 0), |
| row(0, set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, set(4, 5, 6)), |
| row(0, set(4, 5, 6), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, set()), |
| row(0, set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b IN ?", 0, list(set(4, 5, 6), set())), |
| row(0, set(), 0), |
| row(0, set(4, 5, 6), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b > ?", 0, set(4, 5, 6)), |
| row(0, set(7, 8, 9), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b >= ?", 0, set(4, 5, 6)), |
| row(0, set(4, 5, 6), 0), |
| row(0, set(7, 8, 9), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b < ?", 0, set(4, 5, 6)), |
| row(0, set(), 0), |
| row(0, set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b <= ?", 0, set(4, 5, 6)), |
| row(0, set(), 0), |
| row(0, set(1, 2, 3), 0), |
| row(0, set(4, 5, 6), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b > ? AND b <= ?", 0, set(1, 2, 3), set(4, 5, 6)), |
| row(0, set(4, 5, 6), 0) |
| ); |
| |
| execute("DELETE FROM %s WHERE a=? AND b=?", 0, set()); |
| execute("DELETE FROM %s WHERE a=? AND b=?", 0, set(4, 5, 6)); |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, set(1, 2, 3), 0), |
| row(0, set(7, 8, 9), 0) |
| ); |
| } |
| } |
| |
| @Test |
| public void testNestedClusteringKeyUsage() throws Throwable |
| { |
| for (String option : Arrays.asList("", " WITH COMPACT STORAGE")) |
| { |
| createTable("CREATE TABLE %s (a int, b frozen<map<set<int>, list<int>>>, c frozen<set<int>>, d int, PRIMARY KEY (a, b, c))" + option); |
| |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(), set(), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(set(), list(1, 2, 3)), set(), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, map(), set(), 0), |
| row(0, map(set(), list(1, 2, 3)), set(), 0), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT b FROM %s"), |
| row(map()), |
| row(map(set(), list(1, 2, 3))), |
| row(map(set(1, 2, 3), list(1, 2, 3))), |
| row(map(set(4, 5, 6), list(1, 2, 3))), |
| row(map(set(7, 8, 9), list(1, 2, 3))) |
| ); |
| |
| assertRows(execute("SELECT c FROM %s"), |
| row(set()), |
| row(set()), |
| row(set(1, 2, 3)), |
| row(set(1, 2, 3)), |
| row(set(1, 2, 3)) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s LIMIT 3"), |
| row(0, map(), set(), 0), |
| row(0, map(set(), list(1, 2, 3)), set(), 0), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=0 ORDER BY b DESC LIMIT 4"), |
| row(0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(), list(1, 2, 3)), set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, map()), |
| row(0, map(), set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, map(set(), list(1, 2, 3))), |
| row(0, map(set(), list(1, 2, 3)), set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, map(set(1, 2, 3), list(1, 2, 3))), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=? AND c=?", 0, map(set(), list(1, 2, 3)), set()), |
| row(0, map(set(), list(1, 2, 3)), set(), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND (b, c) IN ?", 0, list(tuple(map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3)), |
| tuple(map(), set()))), |
| row(0, map(), set(), 0), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b > ?", 0, map(set(4, 5, 6), list(1, 2, 3))), |
| row(0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b >= ?", 0, map(set(4, 5, 6), list(1, 2, 3))), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b < ?", 0, map(set(4, 5, 6), list(1, 2, 3))), |
| row(0, map(), set(), 0), |
| row(0, map(set(), list(1, 2, 3)), set(), 0), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b <= ?", 0, map(set(4, 5, 6), list(1, 2, 3))), |
| row(0, map(), set(), 0), |
| row(0, map(set(), list(1, 2, 3)), set(), 0), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b > ? AND b <= ?", 0, map(set(1, 2, 3), list(1, 2, 3)), map(set(4, 5, 6), list(1, 2, 3))), |
| row(0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| |
| execute("DELETE FROM %s WHERE a=? AND b=? AND c=?", 0, map(), set()); |
| assertEmpty(execute("SELECT * FROM %s WHERE a=? AND b=? AND c=?", 0, map(), set())); |
| |
| execute("DELETE FROM %s WHERE a=? AND b=? AND c=?", 0, map(set(), list(1, 2, 3)), set()); |
| assertEmpty(execute("SELECT * FROM %s WHERE a=? AND b=? AND c=?", 0, map(set(), list(1, 2, 3)), set())); |
| |
| execute("DELETE FROM %s WHERE a=? AND b=? AND c=?", 0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3)); |
| assertEmpty(execute("SELECT * FROM %s WHERE a=? AND b=? AND c=?", 0, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3))); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3), 0), |
| row(0, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3), 0) |
| ); |
| } |
| } |
| |
| @Test |
| public void testNormalColumnUsage() throws Throwable |
| { |
| for (String option : Arrays.asList("", " WITH COMPACT STORAGE")) |
| { |
| createTable("CREATE TABLE %s (a int PRIMARY KEY, b frozen<map<set<int>, list<int>>>, c frozen<set<int>>)" + option); |
| |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 0, map(), set()); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 1, map(set(), list(99999, 999999, 99999)), set()); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 2, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3)); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 3, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3)); |
| execute("INSERT INTO %s (a, b, c) VALUES (?, ?, ?)", 4, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3)); |
| |
| // overwrite with update |
| execute ("UPDATE %s SET b=? WHERE a=?", map(set(), list(1, 2, 3)), 1); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, map(), set()), |
| row(1, map(set(), list(1, 2, 3)), set()), |
| row(2, map(set(1, 2, 3), list(1, 2, 3)), set(1, 2, 3)), |
| row(3, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3)), |
| row(4, map(set(7, 8, 9), list(1, 2, 3)), set(1, 2, 3)) |
| ); |
| |
| assertRows(execute("SELECT b FROM %s"), |
| row(map()), |
| row(map(set(), list(1, 2, 3))), |
| row(map(set(1, 2, 3), list(1, 2, 3))), |
| row(map(set(4, 5, 6), list(1, 2, 3))), |
| row(map(set(7, 8, 9), list(1, 2, 3))) |
| ); |
| |
| assertRows(execute("SELECT c FROM %s"), |
| row(set()), |
| row(set()), |
| row(set(1, 2, 3)), |
| row(set(1, 2, 3)), |
| row(set(1, 2, 3)) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 3), |
| row(3, map(set(4, 5, 6), list(1, 2, 3)), set(1, 2, 3)) |
| ); |
| |
| execute("UPDATE %s SET b=? WHERE a=?", null, 1); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 1), |
| row(1, null, set()) |
| ); |
| |
| execute("UPDATE %s SET b=? WHERE a=?", map(), 1); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 1), |
| row(1, map(), set()) |
| ); |
| |
| execute("UPDATE %s SET c=? WHERE a=?", null, 2); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 2), |
| row(2, map(set(1, 2, 3), list(1, 2, 3)), null) |
| ); |
| |
| execute("UPDATE %s SET c=? WHERE a=?", set(), 2); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 2), |
| row(2, map(set(1, 2, 3), list(1, 2, 3)), set()) |
| ); |
| |
| execute("DELETE b FROM %s WHERE a=?", 3); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 3), |
| row(3, null, set(1, 2, 3)) |
| ); |
| |
| execute("DELETE c FROM %s WHERE a=?", 4); |
| assertRows(execute("SELECT * FROM %s WHERE a=?", 4), |
| row(4, map(set(7, 8, 9), list(1, 2, 3)), null) |
| ); |
| } |
| } |
| |
| @Test |
| public void testStaticColumnUsage() throws Throwable |
| { |
| createTable("CREATE TABLE %s (a int, b int, c frozen<map<set<int>, list<int>>> static, d int, PRIMARY KEY (a, b))"); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 0, map(), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, 1, map(), 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 1, 0, map(set(), list(1, 2, 3)), 0); |
| execute("INSERT INTO %s (a, b, d) VALUES (?, ?, ?)", 1, 1, 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 2, 0, map(set(1, 2, 3), list(1, 2, 3)), 0); |
| |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, 0, map(), 0), |
| row(0, 1, map(), 0), |
| row(1, 0, map(set(), list(1, 2, 3)), 0), |
| row(1, 1, map(set(), list(1, 2, 3)), 0), |
| row(2, 0, map(set(1, 2, 3), list(1, 2, 3)), 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND b=?", 0, 1), |
| row(0, 1, map(), 0) |
| ); |
| |
| execute("DELETE c FROM %s WHERE a=?", 0); |
| assertRows(execute("SELECT * FROM %s"), |
| row(0, 0, null, 0), |
| row(0, 1, null, 0), |
| row(1, 0, map(set(), list(1, 2, 3)), 0), |
| row(1, 1, map(set(), list(1, 2, 3)), 0), |
| row(2, 0, map(set(1, 2, 3), list(1, 2, 3)), 0) |
| ); |
| |
| execute("DELETE FROM %s WHERE a=?", 0); |
| assertRows(execute("SELECT * FROM %s"), |
| row(1, 0, map(set(), list(1, 2, 3)), 0), |
| row(1, 1, map(set(), list(1, 2, 3)), 0), |
| row(2, 0, map(set(1, 2, 3), list(1, 2, 3)), 0) |
| ); |
| |
| execute("UPDATE %s SET c=? WHERE a=?", map(set(1, 2, 3), list(1, 2, 3)), 1); |
| assertRows(execute("SELECT * FROM %s"), |
| row(1, 0, map(set(1, 2, 3), list(1, 2, 3)), 0), |
| row(1, 1, map(set(1, 2, 3), list(1, 2, 3)), 0), |
| row(2, 0, map(set(1, 2, 3), list(1, 2, 3)), 0) |
| ); |
| } |
| |
| private void assertInvalidCreateWithMessage(String createTableStatement, String errorMessage) throws Throwable |
| { |
| try |
| { |
| createTableMayThrow(createTableStatement); |
| Assert.fail("Expected CREATE TABLE statement to error: " + createTableStatement); |
| } |
| catch (InvalidRequestException | ConfigurationException | SyntaxException ex) |
| { |
| Assert.assertTrue("Expected error message to contain '" + errorMessage + "', but got '" + ex.getMessage() + "'", |
| ex.getMessage().contains(errorMessage)); |
| } |
| } |
| |
| @Test |
| public void testInvalidOperations() throws Throwable |
| { |
| // lists |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, l frozen<list<int>>)"); |
| assertInvalid("UPDATE %s SET l[?]=? WHERE k=?", 0, 0, 0); |
| assertInvalid("UPDATE %s SET l = ? + l WHERE k=?", list(0), 0); |
| assertInvalid("UPDATE %s SET l = l + ? WHERE k=?", list(4), 0); |
| assertInvalid("UPDATE %s SET l = l - ? WHERE k=?", list(3), 0); |
| assertInvalid("DELETE l[?] FROM %s WHERE k=?", 0, 0); |
| |
| // sets |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, s frozen<set<int>>)"); |
| assertInvalid("UPDATE %s SET s = s + ? WHERE k=?", set(0), 0); |
| assertInvalid("UPDATE %s SET s = s - ? WHERE k=?", set(3), 0); |
| |
| // maps |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, m frozen<map<int, int>>)"); |
| assertInvalid("UPDATE %s SET m[?]=? WHERE k=?", 0, 0, 0); |
| assertInvalid("UPDATE %s SET m = m + ? WHERE k=?", map(4, 4), 0); |
| assertInvalid("DELETE m[?] FROM %s WHERE k=?", 0, 0); |
| |
| assertInvalidCreateWithMessage("CREATE TABLE %s (k int PRIMARY KEY, t set<set<int>>)", |
| "Non-frozen collections are not allowed inside collections"); |
| |
| assertInvalidCreateWithMessage("CREATE TABLE %s (k int PRIMARY KEY, t frozen<set<counter>>)", |
| "Counters are not allowed inside collections"); |
| |
| assertInvalidCreateWithMessage("CREATE TABLE %s (k int PRIMARY KEY, t frozen<text>)", |
| "frozen<> is only allowed on collections, tuples, and user-defined types"); |
| } |
| |
| private void assertInvalidIndexCreationWithMessage(String statement, String errorMessage) throws Throwable |
| { |
| try |
| { |
| createIndexMayThrow(statement); |
| Assert.fail("Expected index creation to fail: " + statement); |
| } |
| catch (InvalidRequestException ex) |
| { |
| Assert.assertTrue("Expected error message to contain '" + errorMessage + "', but got '" + ex.getMessage() + "'", |
| ex.getMessage().contains(errorMessage)); |
| } |
| } |
| |
| @Test |
| public void testSecondaryIndex() throws Throwable |
| { |
| createTable("CREATE TABLE %s (a frozen<map<int, text>> PRIMARY KEY, b frozen<map<int, text>>)"); |
| |
| // for now, we don't support indexing values or keys of collections in the primary key |
| assertInvalidIndexCreationWithMessage("CREATE INDEX ON %s (full(a))", "Cannot create secondary index on partition key column"); |
| assertInvalidIndexCreationWithMessage("CREATE INDEX ON %s (keys(a))", "Cannot create secondary index on partition key column"); |
| assertInvalidIndexCreationWithMessage("CREATE INDEX ON %s (keys(b))", "Cannot create keys() index on frozen column b. " + |
| "Frozen collections only support full() indexes"); |
| |
| createTable("CREATE TABLE %s (a int, b frozen<list<int>>, c frozen<set<int>>, d frozen<map<int, text>>, PRIMARY KEY (a, b))"); |
| |
| createIndex("CREATE INDEX ON %s (full(b))"); |
| createIndex("CREATE INDEX ON %s (full(c))"); |
| createIndex("CREATE INDEX ON %s (full(d))"); |
| |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, list(1, 2, 3), set(1, 2, 3), map(1, "a")); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, list(4, 5, 6), set(1, 2, 3), map(1, "a")); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 1, list(1, 2, 3), set(4, 5, 6), map(2, "b")); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 1, list(4, 5, 6), set(4, 5, 6), map(2, "b")); |
| |
| // CONTAINS KEY doesn't work on non-maps |
| assertInvalidMessage("Cannot use CONTAINS KEY on non-map column", |
| "SELECT * FROM %s WHERE b CONTAINS KEY ?", 1); |
| |
| assertInvalidMessage("Cannot use CONTAINS KEY on non-map column", |
| "SELECT * FROM %s WHERE b CONTAINS KEY ? ALLOW FILTERING", 1); |
| |
| assertInvalidMessage("Cannot use CONTAINS KEY on non-map column", |
| "SELECT * FROM %s WHERE c CONTAINS KEY ?", 1); |
| |
| // normal indexes on frozen collections don't support CONTAINS or CONTAINS KEY |
| assertInvalidMessage("Cannot restrict clustering columns by a CONTAINS relation without a secondary index", |
| "SELECT * FROM %s WHERE b CONTAINS ?", 1); |
| |
| assertInvalidMessage("Cannot restrict clustering columns by a CONTAINS relation without a secondary index", |
| "SELECT * FROM %s WHERE b CONTAINS ? ALLOW FILTERING", 1); |
| |
| assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE, |
| "SELECT * FROM %s WHERE d CONTAINS KEY ?", 1); |
| |
| assertInvalidMessage("Cannot restrict clustering columns by a CONTAINS relation without a secondary index", |
| "SELECT * FROM %s WHERE b CONTAINS ? AND d CONTAINS KEY ? ALLOW FILTERING", 1, 1); |
| |
| // index lookup on b |
| assertRows(execute("SELECT * FROM %s WHERE b=?", list(1, 2, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(1, list(1, 2, 3), set(4, 5, 6), map(2, "b")) |
| ); |
| |
| assertEmpty(execute("SELECT * FROM %s WHERE b=?", list(-1))); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE b=? AND c=?", list(1, 2, 3), set(4, 5, 6)); |
| assertRows(execute("SELECT * FROM %s WHERE b=? AND c=? ALLOW FILTERING", list(1, 2, 3), set(4, 5, 6)), |
| row(1, list(1, 2, 3), set(4, 5, 6), map(2, "b")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE b=? AND c CONTAINS ?", list(1, 2, 3), 5); |
| assertRows(execute("SELECT * FROM %s WHERE b=? AND c CONTAINS ? ALLOW FILTERING", list(1, 2, 3), 5), |
| row(1, list(1, 2, 3), set(4, 5, 6), map(2, "b")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE b=? AND d=?", list(1, 2, 3), map(1, "a")); |
| assertRows(execute("SELECT * FROM %s WHERE b=? AND d=? ALLOW FILTERING", list(1, 2, 3), map(1, "a")), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE b=? AND d CONTAINS ?", list(1, 2, 3), "a"); |
| assertRows(execute("SELECT * FROM %s WHERE b=? AND d CONTAINS ? ALLOW FILTERING", list(1, 2, 3), "a"), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE b=? AND d CONTAINS KEY ?", list(1, 2, 3), 1); |
| assertRows(execute("SELECT * FROM %s WHERE b=? AND d CONTAINS KEY ? ALLOW FILTERING", list(1, 2, 3), 1), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| // index lookup on c |
| assertRows(execute("SELECT * FROM %s WHERE c=?", set(1, 2, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| // ordering of c should not matter |
| assertRows(execute("SELECT * FROM %s WHERE c=?", set(2, 1, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertEmpty(execute("SELECT * FROM %s WHERE c=?", set(-1))); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE c=? AND b=?", set(1, 2, 3), list(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND b=? ALLOW FILTERING", set(1, 2, 3), list(1, 2, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE c=? AND b CONTAINS ?", set(1, 2, 3), 1); |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND b CONTAINS ? ALLOW FILTERING", set(1, 2, 3), 1), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE c=? AND d = ?", set(1, 2, 3), map(1, "a")); |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND d = ? ALLOW FILTERING", set(1, 2, 3), map(1, "a")), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE c=? AND d CONTAINS ?", set(1, 2, 3), "a"); |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND d CONTAINS ? ALLOW FILTERING", set(1, 2, 3), "a"), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE c=? AND d CONTAINS KEY ?", set(1, 2, 3), 1); |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND d CONTAINS KEY ? ALLOW FILTERING", set(1, 2, 3), 1), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| // index lookup on d |
| assertRows(execute("SELECT * FROM %s WHERE d=?", map(1, "a")), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE d=?", map(2, "b")), |
| row(1, list(1, 2, 3), set(4, 5, 6), map(2, "b")), |
| row(1, list(4, 5, 6), set(4, 5, 6), map(2, "b")) |
| ); |
| |
| assertEmpty(execute("SELECT * FROM %s WHERE d=?", map(3, "c"))); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE d=? AND c=?", map(1, "a"), set(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b=? ALLOW FILTERING", map(1, "a"), list(1, 2, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE d=? AND b CONTAINS ?", map(1, "a"), 3); |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b CONTAINS ? ALLOW FILTERING", map(1, "a"), 3), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertInvalidMessage("ALLOW FILTERING", "SELECT * FROM %s WHERE d=? AND b=? AND c=?", map(1, "a"), list(1, 2, 3), set(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b=? AND c=? ALLOW FILTERING", map(1, "a"), list(1, 2, 3), set(1, 2, 3)), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b CONTAINS ? AND c CONTAINS ? ALLOW FILTERING", map(1, "a"), 2, 2), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE d CONTAINS KEY ? ALLOW FILTERING", 1), |
| row(0, list(1, 2, 3), set(1, 2, 3), map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| |
| execute("DELETE d FROM %s WHERE a=? AND b=?", 0, list(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE d=?", map(1, "a")), |
| row(0, list(4, 5, 6), set(1, 2, 3), map(1, "a")) |
| ); |
| } |
| |
| /** Test for CASSANDRA-8302 */ |
| @Test |
| public void testClusteringColumnFiltering() throws Throwable |
| { |
| createTable("CREATE TABLE %s (a int, b frozen<map<int, int>>, c int, d int, PRIMARY KEY (a, b, c))"); |
| createIndex("CREATE INDEX c_index ON %s (c)"); |
| createIndex("CREATE INDEX d_index ON %s (d)"); |
| |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(0, 0, 1, 1), 0, 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 0, map(1, 1, 2, 2), 0, 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 1, map(0, 0, 1, 1), 0, 0); |
| execute("INSERT INTO %s (a, b, c, d) VALUES (?, ?, ?, ?)", 1, map(1, 1, 2, 2), 0, 0); |
| |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b CONTAINS ? ALLOW FILTERING", 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0), |
| row(1, map(0, 0, 1, 1), 0, 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE d=? AND b CONTAINS KEY ? ALLOW FILTERING", 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0), |
| row(1, map(0, 0, 1, 1), 0, 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND d=? AND b CONTAINS ? ALLOW FILTERING", 0, 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0) |
| ); |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND d=? AND b CONTAINS KEY ? ALLOW FILTERING", 0, 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0) |
| ); |
| |
| dropIndex("DROP INDEX %s.d_index"); |
| |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND b CONTAINS ? ALLOW FILTERING", 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0), |
| row(1, map(0, 0, 1, 1), 0, 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE c=? AND b CONTAINS KEY ? ALLOW FILTERING", 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0), |
| row(1, map(0, 0, 1, 1), 0, 0) |
| ); |
| |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND c=? AND b CONTAINS ? ALLOW FILTERING", 0, 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0) |
| ); |
| assertRows(execute("SELECT * FROM %s WHERE a=? AND c=? AND b CONTAINS KEY ? ALLOW FILTERING", 0, 0, 0), |
| row(0, map(0, 0, 1, 1), 0, 0) |
| ); |
| } |
| |
| @Test |
| public void testFrozenListInMap() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, m map<frozen<list<int>>, int>)"); |
| |
| execute("INSERT INTO %s (k, m) VALUES (1, {[1, 2, 3] : 1})"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(list(1, 2, 3), 1))); |
| |
| execute("UPDATE %s SET m[[1, 2, 3]]=2 WHERE k=1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(list(1, 2, 3), 2))); |
| |
| execute("UPDATE %s SET m = m + ? WHERE k=1", map(list(4, 5, 6), 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, |
| map(list(1, 2, 3), 2, |
| list(4, 5, 6), 3))); |
| |
| execute("DELETE m[[1, 2, 3]] FROM %s WHERE k = 1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(list(4, 5, 6), 3))); |
| } |
| |
| @Test |
| public void testFrozenListInSet() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, s set<frozen<list<int>>>)"); |
| |
| execute("INSERT INTO %s (k, s) VALUES (1, {[1, 2, 3]})"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(list(1, 2, 3))) |
| ); |
| |
| execute("UPDATE %s SET s = s + ? WHERE k=1", set(list(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(list(1, 2, 3), list(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET s = s - ? WHERE k=1", set(list(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(list(1, 2, 3))) |
| ); |
| |
| execute("DELETE s[[1, 2, 3]] FROM %s WHERE k = 1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, null) |
| ); |
| } |
| |
| @Test |
| public void testFrozenListInList() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, l list<frozen<list<int>>>)"); |
| |
| execute("INSERT INTO %s (k, l) VALUES (1, [[1, 2, 3]])"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(1, 2, 3))) |
| ); |
| |
| execute("UPDATE %s SET l[?]=? WHERE k=1", 0, list(4, 5, 6)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET l = ? + l WHERE k=1", list(list(1, 2, 3))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(1, 2, 3), list(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET l = l + ? WHERE k=1", list(list(7, 8, 9))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(1, 2, 3), list(4, 5, 6), list(7, 8, 9))) |
| ); |
| |
| execute("UPDATE %s SET l = l - ? WHERE k=1", list(list(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(1, 2, 3), list(7, 8, 9))) |
| ); |
| |
| execute("DELETE l[0] FROM %s WHERE k = 1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(list(7, 8, 9))) |
| ); |
| } |
| |
| @Test |
| public void testFrozenMapInMap() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, m map<frozen<map<int, int>>, int>)"); |
| |
| execute("INSERT INTO %s (k, m) VALUES (1, {{1 : 1, 2 : 2} : 1})"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(map(1, 1, 2, 2), 1))); |
| |
| execute("UPDATE %s SET m[?]=2 WHERE k=1", map(1, 1, 2, 2)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(map(1, 1, 2, 2), 2))); |
| |
| execute("UPDATE %s SET m = m + ? WHERE k=1", map(map(3, 3, 4, 4), 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, |
| map(map(1, 1, 2, 2), 2, |
| map(3, 3, 4, 4), 3))); |
| |
| execute("DELETE m[?] FROM %s WHERE k = 1", map(1, 1, 2, 2)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(map(3, 3, 4, 4), 3))); |
| } |
| |
| @Test |
| public void testFrozenMapInSet() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, s set<frozen<map<int, int>>>)"); |
| |
| execute("INSERT INTO %s (k, s) VALUES (1, {{1 : 1, 2 : 2}})"); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(map(1, 1, 2, 2))) |
| ); |
| |
| execute("UPDATE %s SET s = s + ? WHERE k=1", set(map(3, 3, 4, 4))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(map(1, 1, 2, 2), map(3, 3, 4, 4))) |
| ); |
| |
| execute("UPDATE %s SET s = s - ? WHERE k=1", set(map(3, 3, 4, 4))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(map(1, 1, 2, 2))) |
| ); |
| |
| execute("DELETE s[?] FROM %s WHERE k = 1", map(1, 1, 2, 2)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, null) |
| ); |
| } |
| |
| @Test |
| public void testFrozenMapInList() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, l list<frozen<map<int, int>>>)"); |
| |
| execute("INSERT INTO %s (k, l) VALUES (1, [{1 : 1, 2 : 2}])"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(1, 1, 2, 2))) |
| ); |
| |
| execute("UPDATE %s SET l[?]=? WHERE k=1", 0, map(3, 3, 4, 4)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(3, 3, 4, 4))) |
| ); |
| |
| execute("UPDATE %s SET l = ? + l WHERE k=1", list(map(1, 1, 2, 2))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(1, 1, 2, 2), map(3, 3, 4, 4))) |
| ); |
| |
| execute("UPDATE %s SET l = l + ? WHERE k=1", list(map(5, 5, 6, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(1, 1, 2, 2), map(3, 3, 4, 4), map(5, 5, 6, 6))) |
| ); |
| |
| execute("UPDATE %s SET l = l - ? WHERE k=1", list(map(3, 3, 4, 4))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(1, 1, 2, 2), map(5, 5, 6, 6))) |
| ); |
| |
| execute("DELETE l[0] FROM %s WHERE k = 1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(map(5, 5, 6, 6))) |
| ); |
| } |
| |
| @Test |
| public void testFrozenSetInMap() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, m map<frozen<set<int>>, int>)"); |
| |
| execute("INSERT INTO %s (k, m) VALUES (1, {{1, 2, 3} : 1})"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(set(1, 2, 3), 1))); |
| |
| execute("UPDATE %s SET m[?]=2 WHERE k=1", set(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(set(1, 2, 3), 2))); |
| |
| execute("UPDATE %s SET m = m + ? WHERE k=1", map(set(4, 5, 6), 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, |
| map(set(1, 2, 3), 2, |
| set(4, 5, 6), 3))); |
| |
| execute("DELETE m[?] FROM %s WHERE k = 1", set(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, map(set(4, 5, 6), 3))); |
| } |
| |
| @Test |
| public void testFrozenSetInSet() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, s set<frozen<set<int>>>)"); |
| |
| execute("INSERT INTO %s (k, s) VALUES (1, {{1, 2, 3}})"); |
| |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(set(1, 2, 3))) |
| ); |
| |
| execute("UPDATE %s SET s = s + ? WHERE k=1", set(set(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(set(1, 2, 3), set(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET s = s - ? WHERE k=1", set(set(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, set(set(1, 2, 3))) |
| ); |
| |
| execute("DELETE s[?] FROM %s WHERE k = 1", set(1, 2, 3)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, null) |
| ); |
| } |
| |
| @Test |
| public void testFrozenSetInList() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int primary key, l list<frozen<set<int>>>)"); |
| |
| execute("INSERT INTO %s (k, l) VALUES (1, [{1, 2, 3}])"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(1, 2, 3))) |
| ); |
| |
| execute("UPDATE %s SET l[?]=? WHERE k=1", 0, set(4, 5, 6)); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET l = ? + l WHERE k=1", list(set(1, 2, 3))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(1, 2, 3), set(4, 5, 6))) |
| ); |
| |
| execute("UPDATE %s SET l = l + ? WHERE k=1", list(set(7, 8, 9))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(1, 2, 3), set(4, 5, 6), set(7, 8, 9))) |
| ); |
| |
| execute("UPDATE %s SET l = l - ? WHERE k=1", list(set(4, 5, 6))); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(1, 2, 3), set(7, 8, 9))) |
| ); |
| |
| execute("DELETE l[0] FROM %s WHERE k = 1"); |
| assertRows(execute("SELECT * FROM %s WHERE k = 1"), |
| row(1, list(set(7, 8, 9))) |
| ); |
| } |
| |
| @Test |
| public void testUserDefinedTypes() throws Throwable |
| { |
| String myType = createType("CREATE TYPE %s (a set<int>, b tuple<list<int>>)"); |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, v frozen<" + myType + ">)"); |
| execute("INSERT INTO %s (k, v) VALUES (?, {a: ?, b: ?})", 0, set(1, 2, 3), tuple(list(1, 2, 3))); |
| assertRows(execute("SELECT v.a, v.b FROM %s WHERE k=?", 0), |
| row(set(1, 2, 3), tuple(list(1, 2, 3))) |
| ); |
| } |
| |
| private static String clean(String classname) |
| { |
| return StringUtils.remove(classname, "org.apache.cassandra.db.marshal."); |
| } |
| |
| @Test |
| public void testToString() |
| { |
| // set<frozen<list<int>>> |
| SetType t = SetType.getInstance(ListType.getInstance(Int32Type.instance, false), true); |
| assertEquals("SetType(FrozenType(ListType(Int32Type)))", clean(t.toString())); |
| assertEquals("SetType(ListType(Int32Type))", clean(t.toString(true))); |
| |
| // frozen<set<list<int>>> |
| t = SetType.getInstance(ListType.getInstance(Int32Type.instance, false), false); |
| assertEquals("FrozenType(SetType(ListType(Int32Type)))", clean(t.toString())); |
| assertEquals("SetType(ListType(Int32Type))", clean(t.toString(true))); |
| |
| // map<frozen<list<int>>, int> |
| MapType m = MapType.getInstance(ListType.getInstance(Int32Type.instance, false), Int32Type.instance, true); |
| assertEquals("MapType(FrozenType(ListType(Int32Type)),Int32Type)", clean(m.toString())); |
| assertEquals("MapType(ListType(Int32Type),Int32Type)", clean(m.toString(true))); |
| |
| // frozen<map<list<int>, int>> |
| m = MapType.getInstance(ListType.getInstance(Int32Type.instance, false), Int32Type.instance, false); |
| assertEquals("FrozenType(MapType(ListType(Int32Type),Int32Type))", clean(m.toString())); |
| assertEquals("MapType(ListType(Int32Type),Int32Type)", clean(m.toString(true))); |
| |
| // tuple<set<int>> |
| List<AbstractType<?>> types = new ArrayList<>(); |
| types.add(SetType.getInstance(Int32Type.instance, true)); |
| TupleType tuple = new TupleType(types); |
| assertEquals("TupleType(SetType(Int32Type))", clean(tuple.toString())); |
| } |
| |
| @Test |
| public void testListWithElementsBiggerThan64K() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, l frozen<list<text>>)"); |
| |
| byte[] bytes = new byte[FBUtilities.MAX_UNSIGNED_SHORT + 10]; |
| Arrays.fill(bytes, (byte) 1); |
| String largeText = new String(bytes); |
| |
| execute("INSERT INTO %s(k, l) VALUES (0, ?)", list(largeText, "v2")); |
| flush(); |
| |
| assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list(largeText, "v2"))); |
| |
| // Full overwrite |
| execute("UPDATE %s SET l = ? WHERE k = 0", list("v1", largeText)); |
| flush(); |
| |
| assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list("v1", largeText))); |
| |
| execute("DELETE l FROM %s WHERE k = 0"); |
| |
| assertRows(execute("SELECT l FROM %s WHERE k = 0"), row((Object) null)); |
| |
| execute("INSERT INTO %s(k, l) VALUES (0, ['" + largeText + "', 'v2'])"); |
| flush(); |
| |
| assertRows(execute("SELECT l FROM %s WHERE k = 0"), row(list(largeText, "v2"))); |
| } |
| |
| @Test |
| public void testMapsWithElementsBiggerThan64K() throws Throwable |
| { |
| byte[] bytes = new byte[FBUtilities.MAX_UNSIGNED_SHORT + 10]; |
| Arrays.fill(bytes, (byte) 1); |
| String largeText = new String(bytes); |
| |
| bytes = new byte[FBUtilities.MAX_UNSIGNED_SHORT + 10]; |
| Arrays.fill(bytes, (byte) 2); |
| String largeText2 = new String(bytes); |
| |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, m frozen<map<text, text>>)"); |
| |
| execute("INSERT INTO %s(k, m) VALUES (0, ?)", map(largeText, "v1", "k2", largeText)); |
| flush(); |
| |
| assertRows(execute("SELECT m FROM %s WHERE k = 0"), |
| row(map(largeText, "v1", "k2", largeText))); |
| |
| // Full overwrite |
| execute("UPDATE %s SET m = ? WHERE k = 0", map("k5", largeText, largeText2, "v6")); |
| flush(); |
| |
| assertRows(execute("SELECT m FROM %s WHERE k = 0"), |
| row(map("k5", largeText, largeText2, "v6"))); |
| |
| execute("DELETE m FROM %s WHERE k = 0"); |
| |
| assertRows(execute("SELECT m FROM %s WHERE k = 0"), row((Object) null)); |
| |
| execute("INSERT INTO %s(k, m) VALUES (0, {'" + largeText + "' : 'v1', 'k2' : '" + largeText + "'})"); |
| flush(); |
| |
| assertRows(execute("SELECT m FROM %s WHERE k = 0"), |
| row(map(largeText, "v1", "k2", largeText))); |
| } |
| |
| @Test |
| public void testSetsWithElementsBiggerThan64K() throws Throwable |
| { |
| createTable("CREATE TABLE %s (k int PRIMARY KEY, s frozen<set<text>>)"); |
| |
| byte[] bytes = new byte[FBUtilities.MAX_UNSIGNED_SHORT + 10]; |
| Arrays.fill(bytes, (byte) 1); |
| String largeText = new String(bytes); |
| |
| execute("INSERT INTO %s(k, s) VALUES (0, ?)", set(largeText, "v1", "v2")); |
| flush(); |
| |
| assertRows(execute("SELECT s FROM %s WHERE k = 0"), row(set(largeText, "v1", "v2"))); |
| |
| // Full overwrite |
| execute("UPDATE %s SET s = ? WHERE k = 0", set(largeText, "v3")); |
| flush(); |
| |
| assertRows(execute("SELECT s FROM %s WHERE k = 0"), row(set(largeText, "v3"))); |
| |
| execute("DELETE s FROM %s WHERE k = 0"); |
| |
| assertRows(execute("SELECT s FROM %s WHERE k = 0"), row((Object) null)); |
| |
| execute("INSERT INTO %s(k, s) VALUES (0, {'" + largeText + "', 'v1', 'v2'})"); |
| flush(); |
| |
| assertRows(execute("SELECT s FROM %s WHERE k = 0"), row(set(largeText, "v1", "v2"))); |
| } |
| } |
