Add FE constant folding for cosine_similarity and use test{sql,exception} pattern

Co-authored-by: zclllyybb <61408379+zclllyybb@users.noreply.github.com>

Author: Copilot

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/ExpressionEvaluator.java

@@ -19,6 +19,7 @@
 
 import org.apache.doris.nereids.exceptions.NotSupportedException;
 import org.apache.doris.nereids.trees.expressions.functions.BoundFunction;
+import org.apache.doris.nereids.trees.expressions.functions.executable.ArrayArithmetic;
 import org.apache.doris.nereids.trees.expressions.functions.executable.DateTimeAcquire;
 import org.apache.doris.nereids.trees.expressions.functions.executable.DateTimeArithmetic;
 import org.apache.doris.nereids.trees.expressions.functions.executable.DateTimeExtractAndTransform;
@@ -177,6 +178,7 @@ private void registerFunctions() {
         }
         ImmutableMultimap.Builder<String, Method> mapBuilder = new ImmutableMultimap.Builder<>();
         List<Class<?>> classes = ImmutableList.of(
+                ArrayArithmetic.class,
                 DateTimeAcquire.class,
                 DateTimeExtractAndTransform.class,
                 DateLiteral.class,

fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/executable/ArrayArithmetic.java

@@ -0,0 +1,88 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); 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.
+
+package org.apache.doris.nereids.trees.expressions.functions.executable;
+
+import org.apache.doris.nereids.exceptions.AnalysisException;
+import org.apache.doris.nereids.trees.expressions.ExecFunction;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import org.apache.doris.nereids.trees.expressions.literal.ArrayLiteral;
+import org.apache.doris.nereids.trees.expressions.literal.FloatLiteral;
+import org.apache.doris.nereids.trees.expressions.literal.Literal;
+import org.apache.doris.nereids.trees.expressions.literal.NullLiteral;
+
+import java.util.List;
+
+/**
+ * Executable functions for array operations.
+ */
+public class ArrayArithmetic {
+
+    /**
+     * Compute cosine similarity between two float arrays.
+     * cosine_similarity(x, y) = dot(x, y) / (||x|| * ||y||)
+     */
+    @ExecFunction(name = "cosine_similarity")
+    public static Expression cosineSimilarity(ArrayLiteral array1, ArrayLiteral array2) {
+        List<Literal> items1 = array1.getValue();
+        List<Literal> items2 = array2.getValue();
+
+        // Check for null elements
+        for (Literal item : items1) {
+            if (item instanceof NullLiteral) {
+                throw new AnalysisException("function cosine_similarity cannot have null");
+            }
+        }
+        for (Literal item : items2) {
+            if (item instanceof NullLiteral) {
+                throw new AnalysisException("function cosine_similarity cannot have null");
+            }
+        }
+
+        // Check array sizes
+        if (items1.size() != items2.size()) {
+            throw new AnalysisException("function cosine_similarity have different input element sizes of array: "
+                    + items1.size() + " and " + items2.size());
+        }
+
+        // Handle empty arrays
+        if (items1.isEmpty()) {
+            return new FloatLiteral(0.0f);
+        }
+
+        // Compute dot product and squared norms
+        double dotProd = 0.0;
+        double squaredX = 0.0;
+        double squaredY = 0.0;
+
+        for (int i = 0; i < items1.size(); i++) {
+            double x = ((Number) items1.get(i).getValue()).doubleValue();
+            double y = ((Number) items2.get(i).getValue()).doubleValue();
+            dotProd += x * y;
+            squaredX += x * x;
+            squaredY += y * y;
+        }
+
+        // Handle zero vectors
+        if (squaredX == 0.0 || squaredY == 0.0) {
+            return new FloatLiteral(0.0f);
+        }
+
+        float result = (float) (dotProd / Math.sqrt(squaredX * squaredY));
+        return new FloatLiteral(result);
+    }
+}

regression-test/suites/query_p0/sql_functions/array_functions/test_array_distance_functions.groovy

@@ -51,37 +51,32 @@ suite("test_array_distance_functions") {
     }
 
     // abnormal test cases
-    try {
+    test {
         sql "SELECT l2_distance([0, 0], [1])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function l2_distance have different input element sizes"))
+        exception "function l2_distance have different input element sizes"
     }
 
-    try {
+    test {
         sql "SELECT cosine_distance([NULL], [NULL, NULL])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function cosine_distance cannot have null"))
+        exception "function cosine_distance cannot have null"
     }
 
     // Test cases for the nullable array offset fix
     // These cases specifically test scenarios where absolute offsets might differ
     // but actual array sizes are the same (should pass) or different (should fail)
-    try {
+    test {
         sql "SELECT l1_distance([1.0, 2.0, 3.0], [4.0, 5.0])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function l1_distance have different input element sizes"))
+        exception "function l1_distance have different input element sizes"
     }
 
-    try {
+    test {
         sql "SELECT inner_product([1.0], [2.0, 3.0, 4.0])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function inner_product have different input element sizes"))
+        exception "function inner_product have different input element sizes"
     }
 
-    try {
+    test {
         sql "SELECT l1_distance([1, 2, 3], [0, NULL, 0])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function l1_distance cannot have null"))
+        exception "function l1_distance cannot have null"
     }
 
     // Edge case: empty arrays should work
@@ -149,29 +144,25 @@ suite("test_array_distance_functions") {
     }
 
     // Test array with NULL element: should throw exception
-    try {
+    test {
         sql "SELECT cosine_similarity([1, NULL, 3], [4, 5, 6])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function cosine_similarity cannot have null"))
+        exception "function cosine_similarity cannot have null"
     }
 
-    try {
+    test {
         sql "SELECT cosine_similarity([1, 2, 3], [4, NULL, 6])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function cosine_similarity cannot have null"))
+        exception "function cosine_similarity cannot have null"
     }
 
     // Test different array sizes: should throw exception
-    try {
+    test {
         sql "SELECT cosine_similarity([1, 2], [1, 2, 3])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function cosine_similarity have different input element sizes"))
+        exception "function cosine_similarity have different input element sizes"
     }
 
-    try {
+    test {
         sql "SELECT cosine_similarity([1, 2, 3, 4], [1, 2])"
-    } catch (Exception ex) {
-        assert("${ex}".contains("function cosine_similarity have different input element sizes"))
+        exception "function cosine_similarity have different input element sizes"
     }
 
     // Test large values