maedhroz commented on code in PR #4561:
URL: https://github.com/apache/cassandra/pull/4561#discussion_r2825155506
##########
test/unit/org/apache/cassandra/index/sai/cql/StorageAttachedIndexDDLTest.java:
##########
@@ -1359,74 +1362,1114 @@ public void shouldRejectQueriesWithCustomExpressions()
}
@Test
- public void testInitialBuildParallelism()
+ public void testFrozenListFullIndex()
{
- Function<Long, SSTableReader> createMockSSTable = onDiskLength -> {
- SSTableReader reader = Mockito.mock(SSTableReader.class);
- when(reader.onDiskLength()).thenReturn(onDiskLength);
- return reader;
- };
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_list
frozen<list<int>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list)) USING 'sai'");
- Function<List<SSTableReader>, List<Long>> toSize = sstables ->
sstables.stream().map(SSTableReader::onDiskLength).collect(Collectors.toList());
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (1, [1, 2, 3])");
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (2, [1, 2, 3])");
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (3, [4, 5, 6])");
- // total size = 55
- List<SSTableReader> sstables = LongStream.range(1,
11).boxed().map(createMockSSTable).collect(Collectors.toList());
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
Arrays.asList(1, 2, 3));
+ assertEquals(2, rows.all().size());
- // avg = 55 == total size
- List<List<SSTableReader>> groups =
StorageAttachedIndex.groupBySize(sstables, 1);
- Iterator<List<SSTableReader>> iterator = groups.iterator();
- assertEquals(1, groups.size());
- assertEquals(Arrays.asList(10L, 9L, 8L, 7L, 6L, 5L, 4L, 3L, 2L, 1L),
toSize.apply(iterator.next())); // size = 55
+ flush();
- // avg = 27.5
- groups = StorageAttachedIndex.groupBySize(sstables, 2);
- iterator = groups.iterator();
- assertEquals(2, groups.size());
- assertEquals(Arrays.asList(10L, 9L, 8L, 7L),
toSize.apply(iterator.next())); // size = 34
- assertEquals(Arrays.asList(6L, 5L, 4L, 3L, 2L, 1L),
toSize.apply(iterator.next())); // size = 21
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
Arrays.asList(1, 2, 3));
+ assertEquals(2, rows.all().size());
+ }
- // avg = 18.333
- groups = StorageAttachedIndex.groupBySize(sstables, 3);
- iterator = groups.iterator();
- assertEquals(3, groups.size());
- assertEquals(Arrays.asList(10L, 9L), toSize.apply(iterator.next()));
// size = 19
- assertEquals(Arrays.asList(8L, 7L, 6L),
toSize.apply(iterator.next())); // size = 21
- assertEquals(Arrays.asList(5L, 4L, 3L, 2L, 1L),
toSize.apply(iterator.next())); // size = 15
+ @Test
+ public void testFrozenListValuesIndex()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_list
frozen<list<int>>)");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_list)) USING 'sai'");
- // avg = 11
- groups = StorageAttachedIndex.groupBySize(sstables, 5);
- iterator = groups.iterator();
- assertEquals(4, groups.size());
- assertEquals(Arrays.asList(10L, 9L), toSize.apply(iterator.next()));
// size = 19
- assertEquals(Arrays.asList(8L, 7L), toSize.apply(iterator.next())); //
size = 15
- assertEquals(Arrays.asList(6L, 5L), toSize.apply(iterator.next())); //
size = 11
- assertEquals(Arrays.asList(4L, 3L, 2L, 1L),
toSize.apply(iterator.next())); // size = 11
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (1, [1, 2, 3])");
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (2, [3, 4, 5])");
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (3, [4, 5, 6])");
- // avg = 5.5
- groups = StorageAttachedIndex.groupBySize(sstables, 10);
- iterator = groups.iterator();
- assertEquals(7, groups.size());
- assertEquals(singletonList(10L), toSize.apply(iterator.next()));
- assertEquals(singletonList(9L), toSize.apply(iterator.next()));
- assertEquals(singletonList(8L), toSize.apply(iterator.next()));
- assertEquals(singletonList(7L), toSize.apply(iterator.next()));
- assertEquals(singletonList(6L), toSize.apply(iterator.next()));
- assertEquals(Arrays.asList(5L, 4L), toSize.apply(iterator.next()));
- assertEquals(Arrays.asList(3L, 2L, 1L), toSize.apply(iterator.next()));
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_list
CONTAINS 3");
+ assertEquals(2, rows.all().size());
- // avg = 2.75
- groups = StorageAttachedIndex.groupBySize(sstables, 20);
- iterator = groups.iterator();
- assertEquals(9, groups.size());
- assertEquals(singletonList(10L), toSize.apply(iterator.next()));
- assertEquals(singletonList(9L), toSize.apply(iterator.next()));
- assertEquals(singletonList(8L), toSize.apply(iterator.next()));
- assertEquals(singletonList(7L), toSize.apply(iterator.next()));
- assertEquals(singletonList(6L), toSize.apply(iterator.next()));
- assertEquals(singletonList(5L), toSize.apply(iterator.next()));
- assertEquals(singletonList(4L), toSize.apply(iterator.next()));
- assertEquals(singletonList(3L), toSize.apply(iterator.next()));
- assertEquals(Arrays.asList(2L, 1L), toSize.apply(iterator.next()));
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list CONTAINS 3");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenSetFullIndex()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_set
frozen<set<text>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_set)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (1, {'apple',
'banana'})");
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (2, {'apple',
'banana'})");
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (3, {'cherry',
'date'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_set = ?",
Arrays.asList("apple", "banana"));
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set = ?",
Arrays.asList("apple", "banana"));
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenSetValuesIndex()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_set
frozen<set<text>>)");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (1, {'apple',
'banana'})");
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (2, {'banana',
'cherry'})");
+ execute("INSERT INTO %s (pk, frozen_set) VALUES (3, {'cherry',
'date'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_set
CONTAINS 'banana'");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set CONTAINS
'banana'");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapFullIndexEquality()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<text, text>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, {'k3': 'v3', 'k4':
'v4'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map = ?",
ImmutableMap.of("k1", "v1", "k2", "v2"));
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map = ?",
ImmutableMap.of("k1", "v1", "k2", "v2"));
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapFullIndexMapEntryRequiresFiltering() throws
Throwable
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(1, "v1", 3, "v3"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, ?)",
ImmutableMap.of(3, "v3", 4, "v4"));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1' ALLOW FILTERING");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1' ALLOW
FILTERING");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapEntriesIndexMapEntry()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(1, "v1", 3, "v3"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, ?)",
ImmutableMap.of(3, "v3", 4, "v4"));
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1'");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapValuesIndex()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<text, text>>)");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, {'k3': 'v1', 'k4':
'v3'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, {'k5': 'v3', 'k6':
'v4'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map
CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapKeysIndex()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<text, text>>)");
+ createIndex("CREATE INDEX ON %s(KEYS(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, {'k1': 'v3', 'k4':
'v4'})");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, {'k5': 'v5', 'k6':
'v6'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map
CONTAINS KEY 'k1'");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map CONTAINS KEY
'k1'");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testDifferentIndexTypesOnDifferentColumns()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "map_full frozen<map<text, text>>, " +
+ "map_values frozen<map<text, text>>, " +
+ "map_keys frozen<map<text, text>>, " +
+ "map_entries frozen<map<text, text>>)");
+
+ createIndex("CREATE INDEX idx_full ON %s(FULL(map_full)) USING 'sai'");
+ createIndex("CREATE INDEX idx_values ON %s(VALUES(map_values)) USING
'sai'");
+ createIndex("CREATE INDEX idx_keys ON %s(KEYS(map_keys)) USING 'sai'");
+ createIndex("CREATE INDEX idx_entries ON %s(ENTRIES(map_entries))
USING 'sai'");
+
+ execute("INSERT INTO %s (pk, map_full, map_values, map_keys,
map_entries) " +
+ "VALUES (1, {'k1': 'v1', 'k2': 'v2'}, {'k1': 'v1', 'k2':
'v2'}, {'k1': 'v1', 'k2': 'v2'}, {'k1': 'v1', 'k2': 'v2'})");
+ execute("INSERT INTO %s (pk, map_full, map_values, map_keys,
map_entries) " +
+ "VALUES (2, {'k1': 'v1', 'k2': 'v2'}, {'k3': 'v1', 'k4':
'v3'}, {'k1': 'v3', 'k5': 'v5'}, {'k1': 'v1', 'k6': 'v6'})");
+ execute("INSERT INTO %s (pk, map_full, map_values, map_keys,
map_entries) " +
+ "VALUES (3, {'k3': 'v3', 'k4': 'v4'}, {'k5': 'v5', 'k6':
'v6'}, {'k7': 'v7', 'k8': 'v8'}, {'k9': 'v9', 'k10': 'v10'})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE map_full = ?",
ImmutableMap.of("k1", "v1", "k2", "v2"));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_values CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_keys CONTAINS KEY
'k1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_entries['k1'] = 'v1'");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_full = ?",
ImmutableMap.of("k1", "v1", "k2", "v2"));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_values CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_keys CONTAINS KEY
'k1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE map_entries['k1'] = 'v1'");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFullIndexDoesNotSupportContainsOperations()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_list
frozen<list<int>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (1, [1, 2, 3])");
+ flush();
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_list CONTAINS 1");
+ }
+
+ @Test
+ public void testValuesIndexDoesNotSupportEquality()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_list
frozen<list<int>>)");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_list)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (1, [1, 2, 3])");
+ flush();
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_list = ?",
Arrays.asList(1, 2, 3));
+ }
+
+ @Test
+ public void testMapEntryWithAllowFilteringDifferentKeyTypes()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1' ALLOW FILTERING");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1' ALLOW
FILTERING");
+ assertEquals(1, rows.all().size());
+
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<text, text>>)");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of("k1", "v1", "k2", "v2"));
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map['k1'] = 'v1'
ALLOW FILTERING");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map['k1'] = 'v1'
ALLOW FILTERING");
+ assertEquals(1, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapValuesIndexWithMapEntryQuery()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(1, "v1", 3, "v3"));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1' ALLOW FILTERING");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapKeysIndexWithMapEntryQuery()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(KEYS(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(1, "v1", 3, "v3"));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1' ALLOW FILTERING");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenMapDefaultIndexType()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(frozen_map) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(1, "v1", 3, "v3"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, ?)",
ImmutableMap.of(4, "v4", 5, "v5"));
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map
CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map = ?",
ImmutableMap.of(1, "v1", 2, "v2"));
+
+
assertInvalidMessage(StatementRestrictions.REQUIRES_ALLOW_FILTERING_MESSAGE,
+ "SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1' ALLOW
FILTERING");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1' ALLOW
FILTERING");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testMapEntryQueryWithNullAndEmptyCollections()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_map
frozen<map<int, text>>)");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (1, ?)",
ImmutableMap.of(1, "v1", 2, "v2"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (2, ?)",
ImmutableMap.of(3, "v3", 4, "v4"));
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (3, NULL)");
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (4, ?)",
ImmutableMap.of());
+ execute("INSERT INTO %s (pk, frozen_map) VALUES (5, ?)",
ImmutableMap.of(1, "different_value"));
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] =
'v1'");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map[1] = 'v1'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s");
+ assertEquals(5, rows.all().size());
+ }
+
+ @Test
+ public void testFullIndexWithNullAndEmptyCollections()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, frozen_list
frozen<list<int>>)");
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list)) USING 'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (1, ?)",
Arrays.asList(1, 2, 3));
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (2, ?)",
Arrays.asList(1, 2, 3));
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (3, ?)",
Arrays.asList(4, 5, 6));
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (4, NULL)");
+ execute("INSERT INTO %s (pk, frozen_list) VALUES (5, ?)", List.of());
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
Arrays.asList(1, 2, 3));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
List.of());
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
Arrays.asList(1, 2, 3));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list = ?",
List.of());
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s");
+ assertEquals(5, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenCollectionsWithNumericTypes()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "frozen_list_bigint frozen<list<bigint>>, " +
+ "frozen_set_smallint frozen<set<smallint>>, " +
+ "frozen_map_tinyint frozen<map<tinyint, text>>, " +
+ "frozen_list_varint frozen<list<varint>>)");
+
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list_bigint)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set_smallint)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map_tinyint)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_list_varint)) USING
'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list_bigint, frozen_set_smallint,
frozen_map_tinyint, frozen_list_varint) " +
+ "VALUES (1, [1, 2, 3], {10, 20}, {1: 'v1', 2: 'v2'}, [100,
200])");
+ execute("INSERT INTO %s (pk, frozen_list_bigint, frozen_set_smallint,
frozen_map_tinyint, frozen_list_varint) " +
+ "VALUES (2, [1, 2, 3], {30, 40}, {3: 'v3'}, [300])");
+ execute("INSERT INTO %s (pk, frozen_list_bigint, frozen_set_smallint,
frozen_map_tinyint, frozen_list_varint) " +
+ "VALUES (3, [], {}, {}, [])");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE
frozen_list_bigint = ?", Arrays.asList(1L, 2L, 3L));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_smallint
CONTAINS ?", (short)10);
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_tinyint[?] =
'v1'", (byte)1);
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_varint CONTAINS
100");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_bigint = ?",
Arrays.asList(1L, 2L, 3L));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_smallint
CONTAINS ?", (short)10);
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_tinyint[?] =
'v1'", (byte)1);
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_varint CONTAINS
100");
+ assertEquals(1, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenCollectionsWithDecimalTypes()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "frozen_list_float frozen<list<float>>, " +
+ "frozen_set_double frozen<set<double>>, " +
+ "frozen_map_decimal frozen<map<decimal, text>>)");
+
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list_float)) USING 'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set_double)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map_decimal)) USING
'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list_float, frozen_set_double,
frozen_map_decimal) " +
+ "VALUES (1, [1.1, 2.2], {10.5, 20.5}, {1.0: 'v1', 2.0: 'v2'})");
+ execute("INSERT INTO %s (pk, frozen_list_float, frozen_set_double,
frozen_map_decimal) " +
+ "VALUES (2, [1.1, 2.2], {30.5}, {3.0: 'v3'})");
+ execute("INSERT INTO %s (pk, frozen_list_float, frozen_set_double,
frozen_map_decimal) " +
+ "VALUES (3, [], {}, {})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_list_float
= ?", Arrays.asList(1.1f, 2.2f));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_double CONTAINS
10.5");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_decimal[1.0] =
'v1'");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_float = ?",
Arrays.asList(1.1f, 2.2f));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_double CONTAINS
10.5");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_decimal[1.0] =
'v1'");
+ assertEquals(1, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenCollectionsWithTextVariants()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "frozen_list_varchar frozen<list<varchar>>, " +
+ "frozen_set_ascii frozen<set<ascii>>, " +
+ "frozen_map_text frozen<map<text, varchar>>)");
+
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list_varchar)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set_ascii)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map_text)) USING
'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list_varchar, frozen_set_ascii,
frozen_map_text) " +
+ "VALUES (1, ['apple', 'banana'], {'hello', 'world'}, {'key1':
'value1', 'key2': 'value2'})");
+ execute("INSERT INTO %s (pk, frozen_list_varchar, frozen_set_ascii,
frozen_map_text) " +
+ "VALUES (2, ['apple', 'banana'], {'test'}, {'key3':
'value3'})");
+ execute("INSERT INTO %s (pk, frozen_list_varchar, frozen_set_ascii,
frozen_map_text) " +
+ "VALUES (3, [], {}, {})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE
frozen_list_varchar = ?", Arrays.asList("apple", "banana"));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_ascii CONTAINS
'hello'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_text['key1'] =
'value1'");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_varchar = ?",
Arrays.asList("apple", "banana"));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_ascii CONTAINS
'hello'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_text['key1'] =
'value1'");
+ assertEquals(1, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenCollectionsWithTimeTypes()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "frozen_list_timestamp frozen<list<timestamp>>, " +
+ "frozen_set_date frozen<set<date>>, " +
+ "frozen_map_time frozen<map<time, text>>, " +
+ "frozen_list_timeuuid frozen<list<timeuuid>>)");
+
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list_timestamp)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set_date)) USING 'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map_time)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_list_timeuuid)) USING
'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list_timestamp, frozen_set_date,
frozen_map_time, frozen_list_timeuuid) " +
+ "VALUES (1, ['2023-01-01 00:00:00+0000', '2023-01-02
00:00:00+0000'], {'2023-01-01', '2023-01-02'}, " +
+ "{'12:00:00': 'noon', '18:00:00': 'evening'},
[50554d6e-29bb-11e5-b345-feff819cdc9f])");
+ execute("INSERT INTO %s (pk, frozen_list_timestamp, frozen_set_date,
frozen_map_time, frozen_list_timeuuid) " +
+ "VALUES (2, ['2023-01-01 00:00:00+0000', '2023-01-02
00:00:00+0000'], {'2023-01-03'}, " +
+ "{'06:00:00': 'morning'},
[50554d6e-29bb-11e5-b345-feff819cdc9f])");
+ execute("INSERT INTO %s (pk, frozen_list_timestamp, frozen_set_date,
frozen_map_time, frozen_list_timeuuid) " +
+ "VALUES (3, [], {}, {}, [])");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE
frozen_list_timestamp = ['2023-01-01 00:00:00+0000', '2023-01-02
00:00:00+0000']");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_date CONTAINS
'2023-01-01'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_time['12:00:00']
= 'noon'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_timeuuid
CONTAINS 50554d6e-29bb-11e5-b345-feff819cdc9f");
+ assertEquals(2, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_timestamp =
['2023-01-01 00:00:00+0000', '2023-01-02 00:00:00+0000']");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_date CONTAINS
'2023-01-01'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_map_time['12:00:00']
= 'noon'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_timeuuid
CONTAINS 50554d6e-29bb-11e5-b345-feff819cdc9f");
+ assertEquals(2, rows.all().size());
+ }
+
+ @Test
+ public void testFrozenCollectionsWithOtherTypes()
+ {
+ createTable("CREATE TABLE %s (pk int PRIMARY KEY, " +
+ "frozen_list_uuid frozen<list<uuid>>, " +
+ "frozen_set_boolean frozen<set<boolean>>, " +
+ "frozen_map_inet frozen<map<inet, text>>)");
+
+ createIndex("CREATE INDEX ON %s(FULL(frozen_list_uuid)) USING 'sai'");
+ createIndex("CREATE INDEX ON %s(VALUES(frozen_set_boolean)) USING
'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map_inet)) USING
'sai'");
+
+ execute("INSERT INTO %s (pk, frozen_list_uuid, frozen_set_boolean,
frozen_map_inet) " +
+ "VALUES (1, [550e8400-e29b-41d4-a716-446655440000,
550e8400-e29b-41d4-a716-446655440001], " +
+ "{true, false}, {'127.0.0.1': 'localhost', '192.168.1.1':
'router'})");
+ execute("INSERT INTO %s (pk, frozen_list_uuid, frozen_set_boolean,
frozen_map_inet) " +
+ "VALUES (2, [550e8400-e29b-41d4-a716-446655440000,
550e8400-e29b-41d4-a716-446655440001], " +
+ "{true}, {'10.0.0.1': 'server'})");
+ execute("INSERT INTO %s (pk, frozen_list_uuid, frozen_map_inet) " +
+ "VALUES (3, [], {})");
+
+ ResultSet rows = executeNet("SELECT pk FROM %s WHERE frozen_list_uuid
= ?",
+
Arrays.asList(UUID.fromString("550e8400-e29b-41d4-a716-446655440000"),
+
UUID.fromString("550e8400-e29b-41d4-a716-446655440001")));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_boolean CONTAINS
true");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE
frozen_map_inet['127.0.0.1'] = 'localhost'");
+ assertEquals(1, rows.all().size());
+
+ flush();
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_list_uuid = ?",
+
Arrays.asList(UUID.fromString("550e8400-e29b-41d4-a716-446655440000"),
+
UUID.fromString("550e8400-e29b-41d4-a716-446655440001")));
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE frozen_set_boolean CONTAINS
true");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT pk FROM %s WHERE
frozen_map_inet['127.0.0.1'] = 'localhost'");
+ assertEquals(1, rows.all().size());
+ }
+
+ @Test
+ public void testNonFrozenCollectionsIndexes()
+ {
+ createTable("CREATE TABLE %s (id int PRIMARY KEY, list_col
list<text>)");
+ createIndex("CREATE INDEX ON %s(VALUES(list_col)) USING 'sai'");
+
+ execute("INSERT INTO %s (id, list_col) VALUES (1, ['apple',
'banana'])");
+ execute("INSERT INTO %s (id, list_col) VALUES (2, ['cherry',
'date'])");
+ execute("INSERT INTO %s (id, list_col) VALUES (3, ['apple', 'banana',
'cherry'])");
+ flush();
+
+ ResultSet rows = executeNet("SELECT id FROM %s WHERE list_col CONTAINS
'apple'");
+ assertEquals(2, rows.all().size());
+
+ createTable("CREATE TABLE %s (id int PRIMARY KEY, set_col set<text>)");
+ createIndex("CREATE INDEX ON %s(VALUES(set_col)) USING 'sai'");
+
+ execute("INSERT INTO %s (id, set_col) VALUES (1, {'apple',
'banana'})");
+ execute("INSERT INTO %s (id, set_col) VALUES (2, {'cherry', 'date'})");
+ execute("INSERT INTO %s (id, set_col) VALUES (3, {'apple', 'banana',
'cherry'})");
+ flush();
+
+ rows = executeNet("SELECT id FROM %s WHERE set_col CONTAINS 'apple'");
+ assertEquals(2, rows.all().size());
+
+ createTable("CREATE TABLE %s (id int PRIMARY KEY, map_col map<text,
text>)");
+ createIndex("CREATE INDEX ON %s(VALUES(map_col)) USING 'sai'");
+ createIndex("CREATE INDEX ON %s(KEYS(map_col)) USING 'sai'");
+ createIndex("CREATE INDEX ON %s(ENTRIES(map_col)) USING 'sai'");
+
+ execute("INSERT INTO %s (id, map_col) VALUES (1, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (id, map_col) VALUES (2, {'k3': 'v3', 'k4':
'v4'})");
+ execute("INSERT INTO %s (id, map_col) VALUES (3, {'k1': 'v1', 'k2':
'v2', 'k3': 'v3'})");
+ flush();
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col CONTAINS 'v1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col CONTAINS key 'k1'");
+ assertEquals(2, rows.all().size());
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col['k1'] = 'v1'");
+ assertEquals(2, rows.all().size());
+
+ execute("UPDATE %s SET map_col = map_col + {'k1': 'v1_updated'} WHERE
id = 1");
+ flush();
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col['k1'] =
'v1_updated'");
+ assertEquals(1, rows.all().size());
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col['k1'] = 'v1'");
+ assertEquals(1, rows.all().size());
+
+ execute("DELETE map_col['k1'] FROM %s WHERE id = 3");
+ flush();
+
+ rows = executeNet("SELECT id FROM %s WHERE map_col CONTAINS key 'k1'");
+ assertEquals(1, rows.all().size());
+
+ assertThatThrownBy(() -> executeNet("SELECT id FROM %s WHERE map_col =
{'k1': 'v1'} ALLOW FILTERING"))
+ .isInstanceOf(Exception.class);
+ }
+
+ @Test
+ public void testSaiNonFrozenMap()
+ {
+ createTable("CREATE TABLE %s (id int PRIMARY KEY, frozen_map map<text,
text>)");
+ createIndex("CREATE INDEX ON %s(ENTRIES(frozen_map)) USING 'sai'");
+
+ execute("INSERT INTO %s (id, frozen_map) VALUES (1, {'k1': 'v1', 'k2':
'v2'})");
+ execute("INSERT INTO %s (id, frozen_map) VALUES (2, {'k3': 'v3', 'k4':
'v4'})");
+ execute("INSERT INTO %s (id, frozen_map) VALUES (3, {'k1': 'v1', 'k2':
'v2', 'k3': 'v3'})");
+ execute("INSERT INTO %s (id, frozen_map) VALUES (4, {'k1': 'v1', 'k2':
'v2', 'k3': 'v3'})");
+ flush();
+
+ ResultSet rows = executeNet("SELECT id FROM %s WHERE
frozen_map['k1']='v1';");
+ assertEquals(3, rows.all().size());
+ }
+
Review Comment:
I'd consider moving basically all of these new tests to
`CollectionIndexingTest` (or at least out of this class). This class is mostly
(I know not purely) meant to look at DDL and operational issues.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
