CNDB-13022: Fix analyzers for collections (#1583)

adelapena · djatnieks · commit 44d9a62aec39 · 2025-03-11T15:58:36.000-05:00
Fix `RowFilter` application of analyzers to queries on collections.

`RowFilter.SimpleExpression#isSatisfiedBy` for `CONTAINS` and
`CONTAINS_KEY` operators should extract the collection values and check
them with `Operator.ANALYZER_MATCHES` rather than with equality.
diff --git a/src/java/org/apache/cassandra/cql3/Operator.java b/src/java/org/apache/cassandra/cql3/Operator.java
@@ -490,9 +490,17 @@ public boolean isSatisfiedBy(AbstractType<?> type,
         {
             assert indexAnalyzer != null && queryAnalyzer != null : ": operation can only be computed by an indexed column with a configured analyzer";
 
-            List<ByteBuffer> leftTokens = indexAnalyzer.analyze(leftOperand);
             List<ByteBuffer> rightTokens = queryAnalyzer.analyze(rightOperand);
+            return isSatisfiedBy(type, leftOperand, rightTokens, indexAnalyzer);
+        }
 
+        @Override
+        public boolean isSatisfiedBy(AbstractType<?> type,
+                                     ByteBuffer leftValue,
+                                     List<ByteBuffer> rightTokens,
+                                     Index.Analyzer indexAnalyzer)
+        {
+            List<ByteBuffer> leftTokens = indexAnalyzer.analyze(leftValue);
             Iterator<ByteBuffer> it = rightTokens.iterator();
 
             do
@@ -640,6 +648,22 @@ public abstract boolean isSatisfiedBy(AbstractType<?> type,
                                           ByteBuffer rightOperand,
                                           @Nullable Index.Analyzer indexAnalyzer,
                                           @Nullable Index.Analyzer queryAnalyzer);
+    /**
+     * Whether 2 analyzable values satisfy this operator (given the type they should be compared with).
+     *
+     * @param type the type of the values to compare.
+     * @param leftOperand the left operand of the comparison.
+     * @param rightTokens the right operand of the comparison decomposed as analyzed tokens.
+     * @param indexAnalyzer an index-provided function to transform the left-side compared value before comparison,
+     * it shouldn't be {@code null}.
+     */
+    public boolean isSatisfiedBy(AbstractType<?> type,
+                                 ByteBuffer leftOperand,
+                                 List<ByteBuffer> rightTokens,
+                                 Index.Analyzer indexAnalyzer)
+    {
+        throw new UnsupportedOperationException();
+    }
 
     public int serializedSize()
     {
diff --git a/src/java/org/apache/cassandra/db/filter/RowFilter.java b/src/java/org/apache/cassandra/db/filter/RowFilter.java
@@ -1372,22 +1372,28 @@ public boolean isSatisfiedBy(TableMetadata metadata, DecoratedKey partitionKey,
         private boolean contains(TableMetadata metadata, DecoratedKey partitionKey, Row row)
         {
             assert column.type.isCollection();
-            CollectionType<?> type = (CollectionType<?>)column.type;
+            assert (indexAnalyzer == null) == (queryAnalyzer == null);
+
+            CollectionType<?> type = (CollectionType<?>) column.type;
+            List<ByteBuffer> analyzedValues = queryAnalyzer == null ? null : queryAnalyzer.analyze(value);
+
             if (column.isComplex())
             {
                 ComplexColumnData complexData = row.getComplexColumnData(column);
                 if (complexData != null)
                 {
+                    AbstractType<?> elementType = type.kind == CollectionType.Kind.SET ? type.nameComparator() : type.valueComparator();
                     for (Cell<?> cell : complexData)
                     {
-                        if (type.kind == CollectionType.Kind.SET)
+                        ByteBuffer elementValue = type.kind == CollectionType.Kind.SET ? cell.path().get(0) : cell.buffer();
+                        if (analyzedValues == null)
                         {
-                            if (type.nameComparator().compare(cell.path().get(0), value) == 0)
+                            if (elementType.compare(elementValue, value) == 0)
                                 return true;
                         }
                         else
                         {
-                            if (type.valueComparator().compare(cell.buffer(), value) == 0)
+                            if (Operator.ANALYZER_MATCHES.isSatisfiedBy(elementType, elementValue, analyzedValues, indexAnalyzer))
                                 return true;
                         }
                     }
@@ -1397,37 +1403,35 @@ private boolean contains(TableMetadata metadata, DecoratedKey partitionKey, Row
             else
             {
                 ByteBuffer foundValue = getValue(metadata, partitionKey, row);
-                if (foundValue == null)
-                    return false;
-
-                switch (type.kind)
-                {
-                    case LIST:
-                        ListType<?> listType = (ListType<?>)type;
-                        return listType.compose(foundValue).contains(listType.getElementsType().compose(value));
-                    case SET:
-                        SetType<?> setType = (SetType<?>)type;
-                        return setType.compose(foundValue).contains(setType.getElementsType().compose(value));
-                    case MAP:
-                        MapType<?,?> mapType = (MapType<?, ?>)type;
-                        return mapType.compose(foundValue).containsValue(mapType.getValuesType().compose(value));
-                }
-                throw new AssertionError();
+                return foundValue != null && Operator.CONTAINS.isSatisfiedBy(type, foundValue, value, indexAnalyzer, queryAnalyzer);
             }
         }
 
         private boolean containsKey(TableMetadata metadata, DecoratedKey partitionKey, Row row)
         {
             assert column.type.isCollection() && column.type instanceof MapType;
-            MapType<?, ?> mapType = (MapType<?, ?>)column.type;
+            MapType<?, ?> mapType = (MapType<?, ?>) column.type;
             if (column.isComplex())
             {
+                if (queryAnalyzer != null)
+                {
+                    assert indexAnalyzer != null;
+                    List<ByteBuffer> values = queryAnalyzer.analyze(value);
+                    for (Cell<?> cell : row.getComplexColumnData(column))
+                    {
+                        AbstractType<?> elementType = mapType.nameComparator();
+                        ByteBuffer elementValue = cell.path().get(0);
+                        if (Operator.ANALYZER_MATCHES.isSatisfiedBy(elementType, elementValue, values, indexAnalyzer))
+                            return true;
+                    }
+                    return false;
+                }
                 return row.getCell(column, CellPath.create(value)) != null;
             }
             else
             {
                 ByteBuffer foundValue = getValue(metadata, partitionKey, row);
-                return foundValue != null && mapType.getSerializer().getSerializedValue(foundValue, value, mapType.getKeysType()) != null;
+                return foundValue != null && Operator.CONTAINS_KEY.isSatisfiedBy(mapType, foundValue, value, indexAnalyzer, queryAnalyzer);
             }
         }
 
diff --git a/test/unit/org/apache/cassandra/index/sai/cql/LuceneAnalyzerTest.java b/test/unit/org/apache/cassandra/index/sai/cql/LuceneAnalyzerTest.java
@@ -862,6 +862,171 @@ public void testClientWarningOnNGram()
                         "   \"filters\":[{\"name\":\"porterstem\"}]}'}");
     }
 
+    @Test
+    public void testAnalyzerOnSet() throws Throwable
+    {
+        createTable("CREATE TABLE %s (id text PRIMARY KEY, genres set<text>)");
+        execute("INSERT INTO %s (id, genres) VALUES ('1', {'Horror', 'comedy'})");
+
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'Horror' ALLOW FILTERING"), row("1"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'Horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'horror' ALLOW FILTERING"), row("1"));
+
+        createIndex("CREATE CUSTOM INDEX ON %s(genres) USING 'StorageAttachedIndex' WITH OPTIONS = { 'index_analyzer':'STANDARD'}");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'horror'"), row("1"));
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'horror'"));
+        });
+    }
+
+    @Test
+    public void testAnalyzerOnSetWithDistinctQueryAnalyzer() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v set<text>, PRIMARY KEY(k, c))");
+        createIndex("CREATE CUSTOM INDEX ON %s(v) USING 'StorageAttachedIndex' WITH OPTIONS = {" +
+                    "'index_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ { \"name\" : \"lowercase\", \"args\": {} }, " +
+                    "                  { \"name\" : \"edgengram\", \"args\": { \"minGramSize\":\"1\", \"maxGramSize\":\"30\" } }]," +
+                    "  \"charFilters\" : []}', " +
+                    "'query_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ {\"name\" : \"lowercase\",\"args\": {}} ]}'}");
+
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 1, {'astra quick fox', 'astra quick foxes', 'astra4', 'astra5 -1@a#', 'lazy dog'})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 2, {'astra quick fox'})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 3, {'astra quick foxes'})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 4, {'astra4'})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 5, {'astra5 -1@a#'})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 6, {'lazy dog'})");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'ast'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra4'"), row(1), row(4));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra5'"), row(1), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra9'"));
+
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'ast'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra4'"), row(2), row(3), row(5), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra5'"), row(2), row(3), row(4), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra9'"), row(1), row(2), row(3), row(4), row(5), row(6));
+        });
+    }
+
+    @Test
+    public void testAnalyzerOnList() throws Throwable
+    {
+        createTable("CREATE TABLE %s (id text PRIMARY KEY, genres list<text>)");
+        execute("INSERT INTO %s (id, genres) VALUES ('1', ['Horror', 'comedy'])");
+
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'Horror' ALLOW FILTERING"), row("1"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'Horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'horror' ALLOW FILTERING"), row("1"));
+
+        createIndex("CREATE CUSTOM INDEX ON %s(genres) USING 'StorageAttachedIndex' WITH OPTIONS = { 'index_analyzer':'STANDARD'}");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS 'horror'"), row("1"));
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS 'horror'"));
+        });
+    }
+
+    @Test
+    public void testAnalyzerOnListWithDistinctQueryAnalyzer() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v list<text>, PRIMARY KEY(k, c))");
+        createIndex("CREATE CUSTOM INDEX ON %s(v) USING 'StorageAttachedIndex' WITH OPTIONS = {" +
+                    "'index_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ { \"name\" : \"lowercase\", \"args\": {} }, " +
+                    "                  { \"name\" : \"edgengram\", \"args\": { \"minGramSize\":\"1\", \"maxGramSize\":\"30\" } }]," +
+                    "  \"charFilters\" : []}', " +
+                    "'query_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ {\"name\" : \"lowercase\",\"args\": {}} ]}'}");
+
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 1, ['astra quick fox', 'astra quick foxes', 'astra4', 'astra5 -1@a#', 'lazy dog'])");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 2, ['astra quick fox'])");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 3, ['astra quick foxes'])");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 4, ['astra4'])");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 5, ['astra5 -1@a#'])");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 6, ['lazy dog'])");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'ast'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra4'"), row(1), row(4));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra5'"), row(1), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS 'astra9'"));
+
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'ast'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra4'"), row(2), row(3), row(5), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra5'"), row(2), row(3), row(4), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS 'astra9'"), row(1), row(2), row(3), row(4), row(5), row(6));
+        });
+    }
+
+    @Test
+    public void testAnalyzerOnMapKeys() throws Throwable
+    {
+        createTable("CREATE TABLE %s (id text PRIMARY KEY, genres map<text, int>)");
+        execute("INSERT INTO %s (id, genres) VALUES ('1', {'Horror' : 1, 'comedy' : 2})");
+
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS KEY 'Horror' ALLOW FILTERING"), row("1"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS KEY 'Horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS KEY 'horror' ALLOW FILTERING"));
+        assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS KEY 'horror' ALLOW FILTERING"), row("1"));
+
+        createIndex("CREATE CUSTOM INDEX ON %s(KEYS(genres)) USING 'StorageAttachedIndex' WITH OPTIONS = { 'index_analyzer':'STANDARD'}");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres CONTAINS KEY 'horror'"), row("1"));
+            assertRowsNet(executeNet("SELECT id FROM %s WHERE genres NOT CONTAINS KEY 'horror'"));
+        });
+    }
+
+    @Test
+    public void testAnalyzerOnMapKeysWithDistinctQueryAnalyzer() throws Throwable
+    {
+        createTable("CREATE TABLE %s (k int, c int, v map<text, int>, PRIMARY KEY(k, c))");
+        createIndex("CREATE CUSTOM INDEX ON %s(KEYS(v)) USING 'StorageAttachedIndex' WITH OPTIONS = {" +
+                    "'index_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ { \"name\" : \"lowercase\", \"args\": {} }, " +
+                    "                  { \"name\" : \"edgengram\", \"args\": { \"minGramSize\":\"1\", \"maxGramSize\":\"30\" } }]," +
+                    "  \"charFilters\" : []}', " +
+                    "'query_analyzer': '{" +
+                    "  \"tokenizer\" : { \"name\" : \"whitespace\", \"args\" : {} }," +
+                    "  \"filters\" : [ {\"name\" : \"lowercase\",\"args\": {}} ]}'}");
+
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 1, {'astra quick fox':0, 'astra quick foxes':0, 'astra4':0, 'astra5 -1@a#':0, 'lazy dog':0})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 2, {'astra quick fox':0})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 3, {'astra quick foxes':0})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 4, {'astra4':0})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 5, {'astra5 -1@a#':0})");
+        execute("INSERT INTO %s (k, c, v) VALUES (0, 6, {'lazy dog':0})");
+
+        beforeAndAfterFlush(() -> {
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS KEY 'ast'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS KEY 'astra'"), row(1), row(2), row(3), row(4), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS KEY 'astra4'"), row(1), row(4));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS KEY 'astra5'"), row(1), row(5));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v CONTAINS KEY 'astra9'"));
+
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS KEY 'ast'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS KEY 'astra'"), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS KEY 'astra4'"), row(2), row(3), row(5), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS KEY 'astra5'"), row(2), row(3), row(4), row(6));
+            assertRowsNet(executeNet("SELECT c FROM %s WHERE v NOT CONTAINS KEY 'astra9'"), row(1), row(2), row(3), row(4), row(5), row(6));
+        });
+    }
+
     private void assertClientWarningOnNGram(String indexOptions)
     {
         createIndexFromOptions(indexOptions);

Original file line number	Diff line number	Diff line change
`@@ -1372,22 +1372,28 @@ public boolean isSatisfiedBy(TableMetadata metadata, DecoratedKey partitionKey,`
`1372`	`1372`	`private boolean contains(TableMetadata metadata, DecoratedKey partitionKey, Row row)`
`1373`	`1373`	`{`
`1374`	`1374`	`assert column.type.isCollection();`
`1375`		`- CollectionType<?> type = (CollectionType<?>)column.type;`
	`1375`	`+ assert (indexAnalyzer == null) == (queryAnalyzer == null);`
	`1376`	`+`
	`1377`	`+ CollectionType<?> type = (CollectionType<?>) column.type;`
	`1378`	`+ List<ByteBuffer> analyzedValues = queryAnalyzer == null ? null : queryAnalyzer.analyze(value);`
	`1379`	`+`
`1376`	`1380`	`if (column.isComplex())`
`1377`	`1381`	`{`
`1378`	`1382`	`ComplexColumnData complexData = row.getComplexColumnData(column);`
`1379`	`1383`	`if (complexData != null)`
`1380`	`1384`	`{`
	`1385`	`+ AbstractType<?> elementType = type.kind == CollectionType.Kind.SET ? type.nameComparator() : type.valueComparator();`
`1381`	`1386`	`for (Cell<?> cell : complexData)`
`1382`	`1387`	`{`
`1383`		`- if (type.kind == CollectionType.Kind.SET)`
	`1388`	`+ ByteBuffer elementValue = type.kind == CollectionType.Kind.SET ? cell.path().get(0) : cell.buffer();`
	`1389`	`+ if (analyzedValues == null)`
`1384`	`1390`	`{`
`1385`		`- if (type.nameComparator().compare(cell.path().get(0), value) == 0)`
	`1391`	`+ if (elementType.compare(elementValue, value) == 0)`
`1386`	`1392`	`return true;`
`1387`	`1393`	`}`
`1388`	`1394`	`else`
`1389`	`1395`	`{`
`1390`		`- if (type.valueComparator().compare(cell.buffer(), value) == 0)`
	`1396`	`+ if (Operator.ANALYZER_MATCHES.isSatisfiedBy(elementType, elementValue, analyzedValues, indexAnalyzer))`
`1391`	`1397`	`return true;`
`1392`	`1398`	`}`
`1393`	`1399`	`}`
`@@ -1397,37 +1403,35 @@ private boolean contains(TableMetadata metadata, DecoratedKey partitionKey, Row`
`1397`	`1403`	`else`
`1398`	`1404`	`{`
`1399`	`1405`	`ByteBuffer foundValue = getValue(metadata, partitionKey, row);`
`1400`		`- if (foundValue == null)`
`1401`		`- return false;`
`1402`		`-`
`1403`		`- switch (type.kind)`
`1404`		`- {`
`1405`		`- case LIST:`
`1406`		`- ListType<?> listType = (ListType<?>)type;`
`1407`		`- return listType.compose(foundValue).contains(listType.getElementsType().compose(value));`
`1408`		`- case SET:`
`1409`		`- SetType<?> setType = (SetType<?>)type;`
`1410`		`- return setType.compose(foundValue).contains(setType.getElementsType().compose(value));`
`1411`		`- case MAP:`
`1412`		`- MapType<?,?> mapType = (MapType<?, ?>)type;`
`1413`		`- return mapType.compose(foundValue).containsValue(mapType.getValuesType().compose(value));`
`1414`		`- }`
`1415`		`- throw new AssertionError();`
	`1406`	`+ return foundValue != null && Operator.CONTAINS.isSatisfiedBy(type, foundValue, value, indexAnalyzer, queryAnalyzer);`
`1416`	`1407`	`}`
`1417`	`1408`	`}`
`1418`	`1409`
`1419`	`1410`	`private boolean containsKey(TableMetadata metadata, DecoratedKey partitionKey, Row row)`
`1420`	`1411`	`{`
`1421`	`1412`	`assert column.type.isCollection() && column.type instanceof MapType;`
`1422`		`- MapType<?, ?> mapType = (MapType<?, ?>)column.type;`
	`1413`	`+ MapType<?, ?> mapType = (MapType<?, ?>) column.type;`
`1423`	`1414`	`if (column.isComplex())`
`1424`	`1415`	`{`
	`1416`	`+ if (queryAnalyzer != null)`
	`1417`	`+ {`
	`1418`	`+ assert indexAnalyzer != null;`
	`1419`	`+ List<ByteBuffer> values = queryAnalyzer.analyze(value);`
	`1420`	`+ for (Cell<?> cell : row.getComplexColumnData(column))`
	`1421`	`+ {`
	`1422`	`+ AbstractType<?> elementType = mapType.nameComparator();`
	`1423`	`+ ByteBuffer elementValue = cell.path().get(0);`
	`1424`	`+ if (Operator.ANALYZER_MATCHES.isSatisfiedBy(elementType, elementValue, values, indexAnalyzer))`
	`1425`	`+ return true;`
	`1426`	`+ }`
	`1427`	`+ return false;`
	`1428`	`+ }`
`1425`	`1429`	`return row.getCell(column, CellPath.create(value)) != null;`
`1426`	`1430`	`}`
`1427`	`1431`	`else`
`1428`	`1432`	`{`
`1429`	`1433`	`ByteBuffer foundValue = getValue(metadata, partitionKey, row);`
`1430`		`- return foundValue != null && mapType.getSerializer().getSerializedValue(foundValue, value, mapType.getKeysType()) != null;`
	`1434`	`+ return foundValue != null && Operator.CONTAINS_KEY.isSatisfiedBy(mapType, foundValue, value, indexAnalyzer, queryAnalyzer);`
`1431`	`1435`	`}`
`1432`	`1436`	`}`
`1433`	`1437`