removing CRTP

Author: clun

File

@@ -68,6 +68,7 @@
 import com.datastax.astra.internal.serdes.DataAPISerializer;
 import com.datastax.astra.internal.serdes.collections.DocumentSerializer;
 import com.datastax.astra.internal.utils.Assert;
+import com.datastax.astra.internal.utils.EscapeUtils;
 import lombok.Getter;
 import lombok.extern.slf4j.Slf4j;
 
@@ -1132,6 +1133,28 @@ public CompletableFuture<Page<T>> findPageASync(Filter filter, CollectionFindOpt
     // ---   distinct       ----
     // -------------------------
 
+    /**
+     * Return a list of distinct values for the given field name.
+     *
+     * @param fieldPath
+     *      chunks of the paths
+     * @param filter
+     *      filter to apply
+     * @param resultClass
+     *      class of the result
+     * @param <R>
+     *     type of the result
+     * @return
+     *   list of distinct values
+     */
+    public <R> Set<R> distinct(String[] fieldPath, Filter filter, Class<R> resultClass) {
+        Assert.notNull(fieldPath, "field path");
+        if (fieldPath.length == 0) {
+            throw new IllegalArgumentException("field path must not be empty");
+        }
+        return distinct(EscapeUtils.escapeFieldNames(fieldPath), filter, resultClass, null);
+    }
+
     /**
      * Return a list of distinct values for the given field name.
      *
@@ -1150,6 +1173,26 @@ public <R> Set<R> distinct(String fieldName, Filter filter, Class<R> resultClass
         return distinct(fieldName, filter, resultClass, null);
     }
 
+    /**
+     * Return a list of distinct values for the given field name.
+     *
+     * @param fieldPath
+     *      segments of the path
+     * @param resultClass
+     *      class of the result
+     * @param <R>
+     *     type of the result
+     * @return
+     *   list of distinct values
+     */
+    public <R> Set<R> distinct(String[] fieldPath, Class<R> resultClass) {
+        Assert.notNull(fieldPath, "field path");
+        if (fieldPath.length == 0) {
+            throw new IllegalArgumentException("field path must not be empty");
+        }
+        return distinct(EscapeUtils.escapeFieldNames(fieldPath), null, resultClass, null);
+    }
+
     /**
      * Return a list of distinct values for the given field name.
      *
@@ -1187,7 +1230,7 @@ public <R> Set<R> distinct(String fieldName, Filter filter, Class<R> resultClass
         Assert.notNull(resultClass, "resultClass");
         // Building a convenient find options
         CollectionFindOptions findOptions =  new CollectionFindOptions()
-                .projection(Projection.include(fieldName));
+                .projection(Projection.include( fieldName.replaceAll("\\[\\d+\\]", "")));
         // Overriding options
         if (options != null && options.getDataAPIClientOptions() != null) {
             findOptions.dataAPIClientOptions(options.getDataAPIClientOptions());

Preferences...

@@ -20,10 +20,14 @@
  * #L%
  */
 
+import com.datastax.astra.client.core.lexical.LexicalAnalyzers;
+import com.datastax.astra.client.core.lexical.LexicalOptions;
+import com.datastax.astra.client.core.reranking.RerankingOptions;
+import com.datastax.astra.client.core.reranking.RerankingProvider;
+import com.datastax.astra.client.core.reranking.RerankingServiceOptions;
 import com.datastax.astra.client.core.vector.SimilarityMetric;
 import com.datastax.astra.client.core.vector.VectorOptions;
 import com.datastax.astra.client.core.vectorize.VectorServiceOptions;
-import lombok.NoArgsConstructor;
 import lombok.NonNull;
 import lombok.Setter;
 import lombok.experimental.Accessors;
@@ -54,6 +58,16 @@ public class CollectionDefinition {
      */
     private IndexingOptions indexing;
 
+    /**
+     * Lexical options
+     */
+    private LexicalOptions lexical;
+
+    /**
+     * Reranking options
+     */
+    private RerankingOptions reranking;
+
     /**
      * Default constructor.
      */
@@ -145,6 +159,7 @@ public VectorOptions getVector() {
         return vector;
     }
 
+
     /**
      * Access the indexing options.
      *
@@ -154,6 +169,24 @@ public IndexingOptions getIndexing() {
         return indexing;
     }
 
+    /**
+     * Gets lexical
+     *
+     * @return value of lexical
+     */
+    public LexicalOptions getLexical() {
+        return lexical;
+    }
+
+    /**
+     * Gets reranking
+     *
+     * @return value of reranking
+     */
+    public RerankingOptions getReranking() {
+        return reranking;
+    }
+
     /**
      * Gets defaultId
      *
@@ -175,6 +208,35 @@ public CollectionDefinition defaultId(CollectionDefaultIdTypes type) {
         return this;
     }
 
+    /**
+     * Builder pattern.
+     *
+     * @param analyzers size
+     * @return self reference
+     */
+    public CollectionDefinition lexical(LexicalAnalyzers analyzers) {
+        if (getLexical() == null) {
+            lexical = new LexicalOptions();
+        }
+        getLexical().enabled(true).analyzer(analyzers);
+        return this;
+    }
+
+    /**
+     * Builder pattern.
+     *
+     * @param reranker
+     *      reranker
+     * @return self reference
+     */
+    public CollectionDefinition reranking(String reranker) {
+        if (getReranking() == null) {
+            reranking = new RerankingOptions();
+        }
+        getReranking().service(new RerankingServiceOptions().provider(reranker));
+        return this;
+    }
+
     /**
      * Builder pattern.
      *

Resources

@@ -355,6 +355,18 @@ public Document vectorize(String text) {
         return appendIfNotNull(DataAPIKeywords.VECTORIZE.getKeyword(), text);
     }
 
+    /**
+     * Add a vectorize attribute to the document.
+     *
+     * @param text
+     *      value for the vectorize attribute
+     * @return
+     *      self reference
+     */
+    public Document lexical(String text) {
+        return appendIfNotNull(DataAPIKeywords.LEXICAL.getKeyword(), text);
+    }
+
     /**
      * Access attribute with vectorize name if any.
      *

astra-db-java/src/main/java/com/datastax/astra/client/collections/Collection.java

@@ -102,7 +102,17 @@ public enum DataAPIKeywords {
     /**
      * VECTORIZE.
      */
-    VECTORIZE("$vectorize");
+    VECTORIZE("$vectorize"),
+
+    /**
+     * LEXICAL.
+     */
+    LEXICAL("$lexical"),
+
+    /**
+     * HYBRID.
+     */
+    HYBRID("$hybrid");;
 
     /**
      * Keyword.

astra-db-java/src/main/java/com/datastax/astra/client/collections/definition/CollectionDefinition.java

@@ -0,0 +1,69 @@
+package com.datastax.astra.client.core.lexical;
+
+/*-
+ * #%L
+ * Data API Java Client
+ * --
+ * Copyright (C) 2024 - 2025 DataStax
+ * --
+ * Licensed under the Apache License, Version 2.0
+ * 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.
+ * #L%
+ */
+
+import lombok.Getter;
+
+@Getter
+public enum LexicalAnalyzers {
+
+    /**
+     * Filters StandardTokenizer output that divides text
+     * into terms on word boundaries and then uses the LowerCaseFilter.
+     */
+    STANDARD("standard"),
+
+    LETTER("letter"),
+
+    LOWERCASE("lowercase"),
+
+    WHITESPACE("whitespace"),
+
+    N_GRAM("n-gram"),
+
+    EDGE_N_GRAM("edge_n-gram"),
+
+    KEYWORD("keyword");
+
+    final String value;
+
+    LexicalAnalyzers(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Build from the key.
+     *
+     * @param value
+     *      string value
+     * @return
+     *      enum value
+     */
+    public static LexicalFilters fromValue(String value) {
+        for (LexicalFilters filter : LexicalFilters.values()) {
+            if (filter.getValue().equalsIgnoreCase(value)) {
+                return filter;
+            }
+        }
+        throw new IllegalArgumentException("Unknown LexicalFilters: " + value);
+    }
+
+}

astra-db-java/src/main/java/com/datastax/astra/client/collections/definition/documents/Document.java

@@ -0,0 +1,64 @@
+package com.datastax.astra.client.core.lexical;
+
+/*-
+ * #%L
+ * Data API Java Client
+ * --
+ * Copyright (C) 2024 - 2025 DataStax
+ * --
+ * Licensed under the Apache License, Version 2.0
+ * 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.
+ * #L%
+ */
+
+import com.datastax.astra.client.core.vector.SimilarityMetric;
+import lombok.Getter;
+
+@Getter
+public enum LexicalFilters {
+
+    /**
+     * Filters StandardTokenizer output that divides text
+     * into terms on word boundaries and then uses the LowerCaseFilter.
+     */
+    LOWERCASE("lowercase"),
+
+    STOP("stop"),
+
+    SYNONYM("synonym"),
+
+    SYNONYM_GRAPH("synonym_graph");
+
+    final String value;
+
+    LexicalFilters(String value) {
+        this.value = value;
+    }
+
+    /**
+     * Build from the key.
+     *
+     * @param value
+     *      string value
+     * @return
+     *      enum value
+     */
+    public static LexicalFilters fromValue(String value) {
+        for (LexicalFilters filter : LexicalFilters.values()) {
+            if (filter.getValue().equalsIgnoreCase(value)) {
+                return filter;
+            }
+        }
+        throw new IllegalArgumentException("Unknown LexicalFilters: " + value);
+    }
+
+}