update sample

Author: clun

astra-db-java/src/main/java/com/datastax/astra/client/collections/commands/cursor/CollectionFindAndRerankCursor.java

@@ -68,8 +68,11 @@ public class CollectionFindAndRerankCursor<T, R> extends AbstractCursor<T, Reran
      * Input Find options. Where will change the different options.
      * Immutable as not setter is provided.
      */
-    private CollectionFindAndRerankOptions options;
+    private final CollectionFindAndRerankOptions options;
 
+    /**
+     * Type of results (different from inputs when projection is used)
+     */
     private Class<R> newRowType;
 
     /**
@@ -81,6 +84,8 @@ public class CollectionFindAndRerankCursor<T, R> extends AbstractCursor<T, Reran
      *      current filter
      * @param options
      *      options of the find operation
+     * @param recordType
+     *      the type of the record
      */
     @SuppressWarnings("unchecked")
     public CollectionFindAndRerankCursor(Collection<T> dataSource, Filter filter, CollectionFindAndRerankOptions options, Class<R> recordType) {
@@ -136,7 +141,8 @@ public CollectionFindAndRerankCursor<T, R> filter(Filter newFilter) {
     /**
      * Creates a new {@link CollectionFindAndRerankCursor} with an updated projection.
      *
-     * @param newProjection the new projection to apply
+     * @param newProjection
+     *      the new projection to apply
      * @return a new {@link CollectionFindAndRerankCursor} instance with the specified projection
      */
     public CollectionFindAndRerankCursor<T, R> project(Projection... newProjection) {
@@ -149,7 +155,8 @@ public CollectionFindAndRerankCursor<T, R> project(Projection... newProjection)
     /**
      * Creates a new {@link CollectionFindAndRerankCursor} with a specified sort order.
      *
-     * @param sort the sort criteria to apply
+     * @param sort
+     *      the sort criteria to apply
      * @return a new {@link CollectionFindAndRerankCursor} instance with the specified sort order
      */
     public CollectionFindAndRerankCursor<T, R> sort(Sort... sort) {

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

@@ -427,17 +427,19 @@ public CollectionDefinition rerank(CollectionRerankOptions collectionRerankOptio
     /**
      * Builder pattern.
      *
-     * @param reranker
-     *      reranker
+     * @param provider
+     *      reranker provider
+     * @param model
+     *      model
      * @return self reference
      */
-    public CollectionDefinition rerank(String reranker) {
+    public CollectionDefinition rerank(String provider, String model) {
         if (getRerank() == null) {
             rerank = new CollectionRerankOptions().enabled(true);
         }
         getRerank()
                 .enabled(true)
-                .service(new RerankServiceOptions().provider(reranker));
+                .service(new RerankServiceOptions().provider(provider).modelName(model));
         return this;
     }
 

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

@@ -358,7 +358,7 @@ public <T> Document id(T id) {
      *      self reference
      */
     public Document vectorize(String passage) {
-        return appendIfNotNull(DataAPIKeywords.VECTORIZE.getKeyword(), Vectorize.of(passage));
+        return appendIfNotNull(DataAPIKeywords.VECTORIZE.getKeyword(), new Vectorize(passage));
     }
 
     /**
@@ -385,7 +385,7 @@ public Document vectorize(Vectorize vectorize) {
      */
     @BetaPreview
     public Document vectorize(String passage, String setPassage) {
-        return appendIfNotNull(DataAPIKeywords.VECTORIZE.getKeyword(), Vectorize.of(passage, setPassage));
+        return appendIfNotNull(DataAPIKeywords.VECTORIZE.getKeyword(), new Vectorize(passage, setPassage));
     }
 
     /**

astra-db-java/src/main/java/com/datastax/astra/client/core/hybrid/HybridLimits.java

@@ -26,21 +26,48 @@
 import java.util.HashMap;
 import java.util.Map;
 
+/**
+ * Represents the limits for lexical and vector data.
+ */
 @Data
 public class HybridLimits {
 
+    /**
+     * The limit for the hybrid data when vectorize and lexical are used.
+     */
     Integer limit;
 
+    /**
+     * The limit for the lexical data.
+     */
     Map<String, Integer> mapOfLimits;
 
+    /**
+     * Constructor.
+     *
+     * @param limit
+     *      the limit for the hybrid data.
+     */
     public HybridLimits(Integer limit) {
         this.limit = limit;
     }
 
+    /**
+     * Constructor.
+     *
+     * @param mapOfLimits
+     *      the map of limits for the hybrid data.
+     */
     public HybridLimits(Map<String, Integer> mapOfLimits) {
         this.mapOfLimits = mapOfLimits;
     }
 
+    /**
+     * Add a limit for the lexical data.
+     *
+     * @param limit
+     *      lexical limit.
+     */
     public HybridLimits lexical(Integer limit) {
         if (mapOfLimits == null) {
             mapOfLimits = new HashMap<>();
@@ -49,6 +76,12 @@ public HybridLimits lexical(Integer limit) {
         return this;
     }
 
+    /**
+     * Add a limit for the vector data.
+     *
+     * @param limit
+     *      vector limit.
+     */
     public HybridLimits vector(Integer limit) {
         if (mapOfLimits == null) {
             mapOfLimits = new HashMap<>();

astra-db-java/src/main/java/com/datastax/astra/client/core/lexical/Analyzer.java

@@ -23,43 +23,100 @@
 import com.datastax.astra.internal.serdes.core.AnalyzerSerializer;
 import com.fasterxml.jackson.databind.annotation.JsonSerialize;
 import lombok.Data;
+import lombok.Getter;
 import lombok.NoArgsConstructor;
 
 import java.util.List;
 import java.util.Map;
 
+/**
+ * Analyzer used for indexing and searching 'lexical' data.
+ */
 @Data
 @JsonSerialize(using = AnalyzerSerializer.class)
 public class Analyzer {
 
-    /** In the case of String analyzer */
+    /** Analyzer definition as a string like 'standard' */
     String strAnalyzer;
 
-    /** In the case of Document analyzer, free structure */
+    /**
+     * Represents the tokenizer used by the analyzer.
+     */
     LexicalFilter tokenizer;
 
+    /** Represents the filters for a text analyzer */
     List<LexicalFilter> filters;
 
+    /** Represents the char filters for a text analyzer */
     List<LexicalFilter> charFilters;
 
+    /**
+     * Default constructor.
+     */
     public Analyzer() {
     }
 
+    /**
+     * Constructor with analyzer definition.
+     *
+     * @param strAnalyzer
+     *      the analyzer definition
+     */
     public Analyzer(String strAnalyzer) {
         this.strAnalyzer = strAnalyzer;
     }
 
+    /**
+     * Constructor with analyzer type.
+     *
+     * @param strAnalyzer
+     *      the analyzer type
+     */
+    public Analyzer(AnalyzerTypes strAnalyzer) {
+       this(strAnalyzer.getValue());
+    }
+
+    /**
+     * Define a tokenizer by its name.
+     *
+     * @param name
+     *      the analyzer name
+     */
     public Analyzer tokenizer(String name) {
         return tokenizer(name, null);
     }
+
+    /**
+     * Define a tokenizer by its name and arguments.
+     *
+     * @param name
+     *      the analyzer name
+     * @param args
+     *      the arguments for the analyzer
+     */
     public Analyzer tokenizer(String name, Map<String, String> args) {
         this.tokenizer = new LexicalFilter().name(name).args(args);;
         return this;
     }
 
+    /**
+     * Adds a filter to the analyzer.
+     *
+     * @param name
+     *      the name of the filter
+     */
     public Analyzer addFilter(String name) {
         return addFilter(name, null);
     }
+
+    /**
+     * Adds a filter to the analyzer.
+     *
+     * @param name
+     *      the name of the filter
+     * @param args
+     *      the arguments for the filter
+     */
     public Analyzer addFilter(String name, Map<String, String> args) {
         if (filters == null) {
             filters = new java.util.ArrayList<>();
@@ -68,9 +125,24 @@ public Analyzer addFilter(String name, Map<String, String> args) {
         return this;
     }
 
+    /**
+     * Adds a char filter to the analyzer.
+     *
+     * @param name
+     *      the name of the filter
+     */
     public Analyzer addChartFilter(String name) {
         return addChartFilter(name, null);
     }
+
+    /**
+     * Adds a char filter to the analyzer.
+     *
+     * @param name
+     *      the name of the filter
+     * @param args
+     *      the arguments for the filter
+     */
     public Analyzer addChartFilter(String name, Map<String, String> args) {
         if (charFilters == null) {
             charFilters = new java.util.ArrayList<>();
@@ -79,44 +151,56 @@ public Analyzer addChartFilter(String name, Map<String, String> args) {
         return this;
     }
 
-    public Analyzer(AnalyzerTypes strAnalyzer) {
-        this.strAnalyzer = strAnalyzer.getValue();
-    }
-
+    /**
+     * Definition of filters and tokenizers
+     */
+    @Getter
     @NoArgsConstructor
     public static class LexicalFilter {
 
+        /** Name of the filter */
         String name;
 
+        /** Arguments for the filter */
         Map<String, String> args;
 
+        /**
+         * Sets the name of the filter.
+         *
+         * @param name
+         *      the name of the filter
+         */
         public LexicalFilter name(String name) {
             this.name = name;
             return this;
         }
 
+        /**
+         * Sets the arguments for the filter.
+         *
+         * @param args
+         *      the arguments for the filter
+         */
         public LexicalFilter args(Map<String, String> args) {
             this.args = args;
             return this;
         }
 
-        public LexicalFilter arg(String key, String value) {
+        /**
+         * Adds an argument to the filter.
+         *
+         * @param key
+         *      the key of the argument
+         * @param value
+         *      the value of the argument
+         */
+        public LexicalFilter addArg(String key, String value) {
             if (args == null) {
                 args = new java.util.HashMap<>();
             }
             args.put(key, value);
             return this;
         }
-
-        public String getName() {
-            return name;
-        }
-
-        public Map<String, String> getArgs() {
-            return args;
-        }
     }
 
-
-
 }