dot product and arrayConcat fix

Author: wu-hui

google-cloud-firestore/pom.xml

@@ -312,6 +312,15 @@
             <descriptorRef>jar-with-dependencies</descriptorRef>
           </descriptorRefs>
         </configuration>
+        <executions>
+          <execution>
+            <id>make-assembly</id>
+            <phase>package</phase>
+            <goals>
+              <goal>single</goal>
+            </goals>
+          </execution>
+        </executions>
       </plugin>
       <plugin>
         <groupId>org.apache.maven.plugins</groupId>

google-cloud-firestore/src/main/java/com/google/cloud/firestore/pipeline/expressions/DotProductDistance.java renamed to google-cloud-firestore/src/main/java/com/google/cloud/firestore/pipeline/expressions/DotProduct.java

@@ -21,9 +21,9 @@
 import com.google.common.collect.Lists;
 
 @BetaApi
-public final class DotProductDistance extends Function {
+public final class DotProduct extends Function {
   @InternalApi
-  DotProductDistance(Expr vector1, Expr vector2) {
+  DotProduct(Expr vector1, Expr vector2) {
     super("dot_product", Lists.newArrayList(vector1, vector2));
   }
 }

google-cloud-firestore/src/main/java/com/google/cloud/firestore/pipeline/expressions/Expr.java

@@ -20,6 +20,7 @@
 
 import com.google.api.core.BetaApi;
 import java.util.Arrays;
+import java.util.List;
 
 /**
  * Represents an expression that can be evaluated to a value within the execution of a {@link
@@ -450,25 +451,7 @@ default Not notInAny(Object... other) {
   // Array Functions
 
   /**
-   * Creates an expression that concatenates an array expression with one or more other arrays.
-   *
-   * <p>Example:
-   *
-   * <pre>{@code
-   * // Combine the 'items' array with another array field.
-   * Field.of("items").arrayConcat(Field.of("otherItems"));
-   * }</pre>
-   *
-   * @param elements The array expressions to concatenate.
-   * @return A new {@code Expr} representing the concatenated array.
-   */
-  @BetaApi
-  default ArrayConcat arrayConcat(Expr... elements) {
-    return new ArrayConcat(this, Arrays.asList(elements));
-  }
-
-  /**
-   * Creates an expression that concatenates an array expression with one or more other arrays.
+   * Creates an expression that concatenates an array expression with another array.
    *
    * <p>Example:
    *
@@ -477,12 +460,12 @@ default ArrayConcat arrayConcat(Expr... elements) {
    * Field.of("tags").arrayConcat(Arrays.asList("newTag1", "newTag2"), Field.of("otherTag"));
    * }</pre>
    *
-   * @param elements The array expressions or values to concatenate.
+   * @param array The array of constants or expressions to concat with.
    * @return A new {@code Expr} representing the concatenated array.
    */
   @BetaApi
-  default ArrayConcat arrayConcat(Object... elements) {
-    return new ArrayConcat(this, toExprList(elements));
+  default ArrayConcat arrayConcat(List<Object> array) {
+    return new ArrayConcat(this, toExprList(array.toArray()));
   }
 
   /**
@@ -1140,39 +1123,39 @@ default EuclideanDistance euclideanDistance(Expr other) {
   }
 
   /**
-   * Calculates the dot product distance between two vectors.
+   * Calculates the dot product between two vectors.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between a feature vector and a target vector
-   * Field.of("features").dotProductDistance(new double[] {0.5, 0.8, 0.2});
+   * // Calculate the dot product between a feature vector and a target vector
+   * Field.of("features").dotProduct(new double[] {0.5, 0.8, 0.2});
    * }</pre>
    *
-   * @param other The other vector (as an array of doubles) to compare against.
-   * @return A new {@code Expr} representing the dot product distance between the two vectors.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
+   * @return A new {@code Expr} representing the dot product between the two vectors.
    */
   @BetaApi
-  default DotProductDistance dotProductDistance(double[] other) {
-    return new DotProductDistance(this, Constant.vector(other));
+  default DotProduct dotProduct(double[] other) {
+    return new DotProduct(this, Constant.vector(other));
   }
 
   /**
-   * Calculates the dot product distance between two vectors.
+   * Calculates the dot product between two vectors.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between two document vectors: 'docVector1' and 'docVector2'
-   * Field.of("docVector1").dotProductDistance(Field.of("docVector2"));
+   * // Calculate the dot product between two document vectors: 'docVector1' and 'docVector2'
+   * Field.of("docVector1").dotProduct(Field.of("docVector2"));
    * }</pre>
    *
-   * @param other The other vector (represented as an Expr) to compare against.
-   * @return A new {@code Expr} representing the dot product distance between the two vectors.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
+   * @return A new {@code Expr} representing the dot product between the two vectors.
    */
   @BetaApi
-  default DotProductDistance dotProductDistance(Expr other) {
-    return new DotProductDistance(this, other);
+  default DotProduct dotProduct(Expr other) {
+    return new DotProduct(this, other);
   }
 
   // Ordering

google-cloud-firestore/src/main/java/com/google/cloud/firestore/pipeline/expressions/Function.java

@@ -1172,79 +1172,41 @@ public static If ifThenElse(FilterCondition condition, Expr thenExpr, Expr elseE
   }
 
   /**
-   * Creates an expression that concatenates an array expression with other arrays.
-   *
-   * <p>Example:
-   *
-   * <pre>{@code
-   * // Combine the 'items' array with two new item arrays
-   * Function.arrayConcat(Field.of("items"), Field.of("newItems"), Field.of("otherItems"));
-   * }</pre>
-   *
-   * @param expr The array expression to concatenate to.
-   * @param elements The array expressions to concatenate.
-   * @return A new {@code Expr} representing the concatenated array.
-   */
-  @BetaApi
-  public static ArrayConcat arrayConcat(Expr expr, Expr... elements) {
-    return new ArrayConcat(expr, Arrays.asList(elements));
-  }
-
-  /**
-   * Creates an expression that concatenates an array expression with other arrays and/or values.
+   * Creates an expression that concatenates an array expression with another array.
    *
    * <p>Example:
    *
    * <pre>{@code
    * // Combine the 'tags' array with a new array
-   * Function.arrayConcat(Field.of("tags"), Arrays.asList("newTag1", "newTag2"));
+   * Function.arrayConcat(Field.of("tags"), List.newArrayList("newTag1", "newTag2"));
    * }</pre>
    *
    * @param expr The array expression to concatenate to.
-   * @param elements The array expressions or single values to concatenate.
-   * @return A new {@code Expr} representing the concatenated array.
-   */
-  @BetaApi
-  public static ArrayConcat arrayConcat(Expr expr, Object... elements) {
-    return new ArrayConcat(expr, toExprList(elements));
-  }
-
-  /**
-   * Creates an expression that concatenates a field's array value with other arrays.
-   *
-   * <p>Example:
-   *
-   * <pre>{@code
-   * // Combine the 'items' array with two new item arrays
-   * Function.arrayConcat("items", Field.of("newItems"), Field.of("otherItems"));
-   * }</pre>
-   *
-   * @param field The field name containing array values.
-   * @param elements The array expressions to concatenate.
+   * @param array The array of constants or expressions to concat with.
    * @return A new {@code Expr} representing the concatenated array.
    */
   @BetaApi
-  public static ArrayConcat arrayConcat(String field, Expr... elements) {
-    return new ArrayConcat(Field.of(field), Arrays.asList(elements));
+  public static ArrayConcat arrayConcat(Expr expr, List<Object> array) {
+    return new ArrayConcat(expr, toExprList(array.toArray()));
   }
 
   /**
-   * Creates an expression that concatenates a field's array value with other arrays and/or values.
+   * Creates an expression that concatenates a field's array value with another array.
    *
    * <p>Example:
    *
    * <pre>{@code
    * // Combine the 'tags' array with a new array
-   * Function.arrayConcat("tags", Arrays.asList("newTag1", "newTag2"));
+   * Function.arrayConcat("tags", List.newArrayList("newTag1", "newTag2"));
    * }</pre>
    *
    * @param field The field name containing array values.
-   * @param elements The array expressions or single values to concatenate.
+   * @param array The array of constants or expressions to concat with.
    * @return A new {@code Expr} representing the concatenated array.
    */
   @BetaApi
-  public static ArrayConcat arrayConcat(String field, Object... elements) {
-    return new ArrayConcat(Field.of(field), toExprList(elements));
+  public static ArrayConcat arrayConcat(String field, List<Object> array) {
+    return new ArrayConcat(Field.of(field), toExprList(array.toArray()));
   }
 
   /**
@@ -2335,79 +2297,79 @@ public static CosineDistance cosineDistance(String field, double[] other) {
   }
 
   /**
-   * Calculates the dot product distance between two vector expressions.
+   * Calculates the dot product between two vector expressions.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between two document vectors: 'docVector1' and 'docVector2'
-   * Function.dotProductDistance(Field.of("docVector1"), Field.of("docVector2"));
+   * // Calculate the dot product between two document vectors: 'docVector1' and 'docVector2'
+   * Function.dotProduct(Field.of("docVector1"), Field.of("docVector2"));
    * }</pre>
    *
-   * @param expr The first vector (represented as an Expr) to compare against.
-   * @param other The other vector (represented as an Expr) to compare against.
-   * @return A new {@code Expr} representing the dot product distance between the two vectors.
+   * @param expr The first vector (represented as an Expr) to calculate dot product with.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
+   * @return A new {@code Expr} representing the dot product between the two vectors.
    */
   @BetaApi
-  public static DotProductDistance dotProductDistance(Expr expr, Expr other) {
-    return new DotProductDistance(expr, other);
+  public static DotProduct dotProduct(Expr expr, Expr other) {
+    return new DotProduct(expr, other);
   }
 
   /**
-   * Calculates the dot product distance between a vector expression and a double array.
+   * Calculates the dot product between a vector expression and a double array.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between a feature vector and a target vector
-   * Function.dotProductDistance(Field.of("features"), new double[] {0.5, 0.8, 0.2});
+   * // Calculate the dot product between a feature vector and a target vector
+   * Function.dotProduct(Field.of("features"), new double[] {0.5, 0.8, 0.2});
    * }</pre>
    *
-   * @param expr The first vector (represented as an Expr) to compare against.
-   * @param other The other vector (as an array of doubles) to compare against.
-   * @return A new {@code Expr} representing the dot product distance between the two vectors.
+   * @param expr The first vector (represented as an Expr) to calculate dot product with.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
+   * @return A new {@code Expr} representing the dot product between the two vectors.
    */
   @BetaApi
-  public static DotProductDistance dotProductDistance(Expr expr, double[] other) {
-    return new DotProductDistance(expr, Constant.vector(other));
+  public static DotProduct dotProduct(Expr expr, double[] other) {
+    return new DotProduct(expr, Constant.vector(other));
   }
 
   /**
-   * Calculates the dot product distance between a field's vector value and a vector expression.
+   * Calculates the dot product between a field's vector value and a vector expression.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between two document vectors: 'docVector1' and 'docVector2'
-   * Function.dotProductDistance("docVector1", Field.of("docVector2"));
+   * // Calculate the dot product between two document vectors: 'docVector1' and 'docVector2'
+   * Function.dotProduct("docVector1", Field.of("docVector2"));
    * }</pre>
    *
    * @param field The name of the field containing the first vector.
-   * @param other The other vector (represented as an Expr) to compare against.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
    * @return A new {@code Expr} representing the dot product distance between the two vectors.
    */
   @BetaApi
-  public static DotProductDistance dotProductDistance(String field, Expr other) {
-    return new DotProductDistance(Field.of(field), other);
+  public static DotProduct dotProduct(String field, Expr other) {
+    return new DotProduct(Field.of(field), other);
   }
 
   /**
-   * Calculates the dot product distance between a field's vector value and a double array.
+   * Calculates the dot product between a field's vector value and a double array.
    *
    * <p>Example:
    *
    * <pre>{@code
-   * // Calculate the dot product distance between a feature vector and a target vector
-   * Function.dotProductDistance("features", new double[] {0.5, 0.8, 0.2});
+   * // Calculate the dot product between a feature vector and a target vector
+   * Function.dotProduct("features", new double[] {0.5, 0.8, 0.2});
    * }</pre>
    *
    * @param field The name of the field containing the first vector.
-   * @param other The other vector (as an array of doubles) to compare against.
+   * @param other The other vector (represented as an Expr) to calculate dot product with.
    * @return A new {@code Expr} representing the dot product distance between the two vectors.
    */
   @BetaApi
-  public static DotProductDistance dotProductDistance(String field, double[] other) {
-    return new DotProductDistance(Field.of(field), Constant.vector(other));
+  public static DotProduct dotProduct(String field, double[] other) {
+    return new DotProduct(Field.of(field), Constant.vector(other));
   }
 
   /**

google-cloud-firestore/src/test/java/com/google/cloud/firestore/it/ITPipelineTest.java

@@ -29,7 +29,6 @@
 import static com.google.cloud.firestore.pipeline.expressions.Function.collectionId;
 import static com.google.cloud.firestore.pipeline.expressions.Function.cosineDistance;
 import static com.google.cloud.firestore.pipeline.expressions.Function.countAll;
-import static com.google.cloud.firestore.pipeline.expressions.Function.dotProductDistance;
 import static com.google.cloud.firestore.pipeline.expressions.Function.endsWith;
 import static com.google.cloud.firestore.pipeline.expressions.Function.eq;
 import static com.google.cloud.firestore.pipeline.expressions.Function.euclideanDistance;
@@ -479,7 +478,10 @@ public void testArrayConcat() throws Exception {
     List<PipelineResult> results =
         collection
             .pipeline()
-            .select(Field.of("tags").arrayConcat("newTag1", "newTag2").as("modifiedTags"))
+            .select(
+                Field.of("tags")
+                    .arrayConcat(Lists.newArrayList("newTag1", "newTag2"))
+                    .as("modifiedTags"))
             .limit(1)
             .execute()
             .get();
@@ -832,7 +834,7 @@ public void testDistanceFunctions() throws Exception {
             .collection(collection.getPath())
             .select(
                 cosineDistance(Constant.vector(sourceVector), targetVector).as("cosineDistance"),
-                dotProductDistance(Constant.vector(sourceVector), targetVector)
+                Function.dotProduct(Constant.vector(sourceVector), targetVector)
                     .as("dotProductDistance"),
                 euclideanDistance(Constant.vector(sourceVector), targetVector)
                     .as("euclideanDistance"))