CNDB-13074: Reject analysis options on frozen collections

src/java/org/apache/cassandra/index/sai/analyzer/AbstractAnalyzer.java

@@ -206,6 +206,9 @@ public static AnalyzerFactory fromOptions(AbstractType<?> type, Map<String, Stri
                                               " combination of case_sensitive, normalize, or ascii options. options=" + options);
         }
 
+        if ((containsIndexAnalyzer || containsNonTokenizingOptions) && type.isCollection() && !type.isMultiCell())
+            throw new InvalidRequestException("Cannot use an analyzer on a frozen collection.");
+
         if (containsIndexAnalyzer)
         {
             String json = options.get(LuceneAnalyzer.INDEX_ANALYZER);

test/unit/org/apache/cassandra/cql3/CQLTester.java

@@ -204,7 +204,7 @@ public abstract class CQLTester
     private static final User SUPER_USER = new User("cassandra", "cassandra");
 
     /**
-     * Whether to use coorfinator execution in {@link #execute(String, Object...)}, so queries get full validation and
+     * Whether to use coordinator execution in {@link #execute(String, Object...)}, so queries get full validation and
      * go through reconciliation. When enabled, calls to {@link #execute(String, Object...)} will behave as calls to
      * {@link #executeWithCoordinator(String, Object...)}. Otherwise, they will behave as calls to
      * {@link #executeInternal(String, Object...)}.

test/unit/org/apache/cassandra/index/sai/SAITester.java

@@ -230,6 +230,23 @@ public static void setUpClass()
         CQLTester.enableCoordinatorExecution();
     }
 
+    /**
+     * Creates a SAI index on the current table, waiting for it to become queryable.
+     *
+     * @param column the name of the indexed column, maybe with {@code FULL()}, {@code KEYS()} or {@code VALUES()} spec
+     * @param options the index options, of the form {@code "{'option1': value1, 'option2': value2, ...}"}.
+     * @return the name of the created index
+     */
+    public String createSAIIndex(String column, @Nullable String options)
+    {
+        String query = String.format(CREATE_INDEX_TEMPLATE, column);
+
+        if (options != null)
+            query += " WITH OPTIONS = " + options;
+
+        return createIndex(query);
+    }
+
     public static IndexContext createIndexContext(String name, AbstractType<?> validator, ColumnFamilyStore cfs)
     {
         return new IndexContext(cfs.getKeyspaceName(),

test/unit/org/apache/cassandra/index/sai/cql/AnalyzerTest.java

@@ -18,9 +18,16 @@
 
 package org.apache.cassandra.index.sai.cql;
 
+import org.apache.cassandra.exceptions.InvalidRequestException;
+import org.apache.cassandra.index.sai.SAITester;
+import org.apache.cassandra.index.sai.analyzer.NonTokenizingOptions;
+import org.assertj.core.api.Assertions;
 import org.junit.Test;
 
-public class AnalyzerTest extends VectorTester
+import javax.annotation.Nullable;
+import java.util.Arrays;
+
+public class AnalyzerTest extends SAITester
 {
     @Test
     public void createAnalyzerWrongTypeTest()
@@ -49,4 +56,72 @@ public void createAnalyzerWrongTypeTest()
         execute("INSERT INTO %s (pk1, pk2, val) VALUES (0, 'c', -2)");
         execute("INSERT INTO %s (pk1, pk2, val) VALUES (1, 'c', -3)");
     }
+
+    /**
+     * Test that we cannot use an analyzer, tokenizing or not, on a frozen collection.
+     */
+    @Test
+    public void analyzerOnFrozenCollectionTest()
+    {
+        createTable("CREATE TABLE %s (k int PRIMARY KEY, l frozen<list<text>>, s frozen<set<text>>, m frozen<map<text, text>>)");
+
+        for (String column : Arrays.asList("l", "s", "m"))
+        {
+            assertRejectsNonFullIndexCreationOnFrozenCollection(column);
+            column = String.format("FULL(%s)", column);
+
+            // non-tokenizing options that produce an analyzer should be rejected
+            assertRejectsAnalyzerOnFrozenCollection(column, String.format("{'%s': %s}", NonTokenizingOptions.CASE_SENSITIVE, false));
+            assertRejectsAnalyzerOnFrozenCollection(column, String.format("{'%s': %s}", NonTokenizingOptions.NORMALIZE, true));
+            assertRejectsAnalyzerOnFrozenCollection(column, String.format("{'%s': %s}", NonTokenizingOptions.ASCII, true));
+
+            // non-tokenizing options that do not produce an analyzer should be accepted
+            assertAcceptsIndexOptions(column, String.format("{'%s': %s}", NonTokenizingOptions.CASE_SENSITIVE, true));
+            assertAcceptsIndexOptions(column, String.format("{'%s': %s}", NonTokenizingOptions.NORMALIZE, false));
+            assertAcceptsIndexOptions(column, String.format("{'%s': %s}", NonTokenizingOptions.ASCII, false));
+
+            // Lucene analyzer should always be rejected
+            assertRejectsAnalyzerOnFrozenCollection(column, "{'index_analyzer': 'standard'}");
+            assertRejectsAnalyzerOnFrozenCollection(column,
+                    "{'index_analyzer': " +
+                    "  '{\"tokenizer\":{\"name\":\"ngram\", \"args\":{\"minGramSize\":\"2\", \"maxGramSize\":\"3\"}}," +
+                    "    \"filters\":[{\"name\":\"lowercase\"}]}'}");
+            assertRejectsAnalyzerOnFrozenCollection(column,
+                    "{'index_analyzer':'\n" +
+                            "  {\"tokenizer\":{\"name\" : \"whitespace\"},\n" +
+                            "   \"filters\":[{\"name\":\"stop\", \"args\": {\"words\": \"the, test\", \"format\": \"wordset\"}}]}'}");
+
+            // no options should be accepted
+            assertAcceptsIndexOptions(column, null);
+            assertAcceptsIndexOptions(column, "{}");
+        }
+    }
+
+    private void assertRejectsNonFullIndexCreationOnFrozenCollection(String column)
+    {
+        Assertions.assertThatThrownBy(() -> createSAIIndex(column, null))
+                  .isInstanceOf(InvalidRequestException.class)
+                  .hasMessageContaining("Cannot create values() index on frozen column " + column);
+
+        Assertions.assertThatThrownBy(() -> createSAIIndex("KEYS(" + column + ')', null))
+                  .isInstanceOf(InvalidRequestException.class)
+                  .hasMessageContaining("Cannot create keys() index on frozen column " + column);
+
+        Assertions.assertThatThrownBy(() -> createSAIIndex("VALUES(" + column + ')', null))
+                  .isInstanceOf(InvalidRequestException.class)
+                  .hasMessageContaining("Cannot create values() index on frozen column " + column);
+    }
+
+    private void assertAcceptsIndexOptions(String column, @Nullable String options)
+    {
+        String index = createSAIIndex(column, options);
+        dropIndex("DROP INDEX %s." + index); // clear for further tests
+    }
+
+    private void assertRejectsAnalyzerOnFrozenCollection(String column, String options)
+    {
+        Assertions.assertThatThrownBy(() -> createSAIIndex(column, options))
+                  .isInstanceOf(InvalidRequestException.class)
+                  .hasMessageContaining("Cannot use an analyzer on a frozen collection.");
+    }
 }