perf: avoid conversion of float[] into List<Float> in SQL engine

lvca · lvca · commit a42ae5e3bf9e · 2026-01-04T16:58:36.000-05:00
diff --git a/engine/src/main/java/com/arcadedb/query/sql/parser/InputParameter.java b/engine/src/main/java/com/arcadedb/query/sql/parser/InputParameter.java
@@ -85,7 +85,12 @@ protected Object toParsedTree(final Object value) {
     if (value instanceof String) {
       return value;
     }
-    if (MultiValue.isMultiValue(value) && !(value instanceof byte[]) && !(value instanceof Byte[])) {
+    // Primitive arrays and their wrapper arrays should be passed as-is to maintain performance
+    // (especially critical for vector operations with float[] parameters)
+    if (isPrimitiveOrWrapperArray(value)) {
+      return value;
+    }
+    if (MultiValue.isMultiValue(value)) {
       final PCollection coll = new PCollection(-1);
       coll.expressions = new ArrayList<Expression>();
       final Iterator iterator = MultiValue.getMultiValueIterator(value);
@@ -149,6 +154,34 @@ protected Object toParsedTree(final Object value) {
     return this;
   }
 
+  /**
+   * Check if value is a primitive array or wrapper array type.
+   * These types should NOT be converted to PCollection for performance reasons.
+   * Primitive arrays are passed directly to functions to avoid boxing overhead,
+   * which is especially critical for vector operations with float[] parameters.
+   *
+   * @param value the value to check
+   * @return true if value is a primitive or wrapper array type
+   */
+  private static boolean isPrimitiveOrWrapperArray(Object value) {
+    return value instanceof byte[] ||
+           value instanceof Byte[] ||
+           value instanceof short[] ||
+           value instanceof Short[] ||
+           value instanceof int[] ||
+           value instanceof Integer[] ||
+           value instanceof long[] ||
+           value instanceof Long[] ||
+           value instanceof float[] ||
+           value instanceof Float[] ||
+           value instanceof double[] ||
+           value instanceof Double[] ||
+           value instanceof boolean[] ||
+           value instanceof Boolean[] ||
+           value instanceof char[] ||
+           value instanceof Character[];
+  }
+
   public InputParameter copy() {
     throw new UnsupportedOperationException();
   }
diff --git a/engine/src/test/java/com/arcadedb/query/sql/parser/InputParameterTest.java b/engine/src/test/java/com/arcadedb/query/sql/parser/InputParameterTest.java
@@ -0,0 +1,258 @@
+/*
+ * Copyright © 2021-present Arcade Data Ltd (info@arcadedata.com)
+ *
+ * Licensed 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.
+ *
+ * SPDX-FileCopyrightText: 2021-present Arcade Data Ltd (info@arcadedata.com)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+package com.arcadedb.query.sql.parser;
+
+import org.junit.jupiter.api.Test;
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Unit tests for InputParameter to verify that primitive arrays are not converted to PCollection.
+ * This is critical for performance, especially for vector operations with float[] parameters.
+ *
+ * @author Luca Garulli (l.garulli@arcadedata.com)
+ */
+class InputParameterTest {
+
+  @Test
+  void testFloatArrayNotConvertedToPCollection() {
+    // Given: A float array parameter (common for vector operations)
+    final float[] floatArray = new float[]{1.0f, 2.0f, 3.0f};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(floatArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(float[].class);
+    assertThat(result).isSameAs(floatArray);
+  }
+
+  @Test
+  void testIntArrayNotConvertedToPCollection() {
+    // Given: An int array parameter
+    final int[] intArray = new int[]{1, 2, 3};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(intArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(int[].class);
+    assertThat(result).isSameAs(intArray);
+  }
+
+  @Test
+  void testDoubleArrayNotConvertedToPCollection() {
+    // Given: A double array parameter
+    final double[] doubleArray = new double[]{1.0, 2.0, 3.0};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(doubleArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(double[].class);
+    assertThat(result).isSameAs(doubleArray);
+  }
+
+  @Test
+  void testLongArrayNotConvertedToPCollection() {
+    // Given: A long array parameter
+    final long[] longArray = new long[]{1L, 2L, 3L};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(longArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(long[].class);
+    assertThat(result).isSameAs(longArray);
+  }
+
+  @Test
+  void testShortArrayNotConvertedToPCollection() {
+    // Given: A short array parameter
+    final short[] shortArray = new short[]{1, 2, 3};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(shortArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(short[].class);
+    assertThat(result).isSameAs(shortArray);
+  }
+
+  @Test
+  void testByteArrayNotConvertedToPCollection() {
+    // Existing behavior should still work
+    final byte[] byteArray = new byte[]{1, 2, 3};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(byteArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(byte[].class);
+    assertThat(result).isSameAs(byteArray);
+  }
+
+  @Test
+  void testBooleanArrayNotConvertedToPCollection() {
+    // Given: A boolean array parameter
+    final boolean[] booleanArray = new boolean[]{true, false, true};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(booleanArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(boolean[].class);
+    assertThat(result).isSameAs(booleanArray);
+  }
+
+  @Test
+  void testCharArrayNotConvertedToPCollection() {
+    // Given: A char array parameter
+    final char[] charArray = new char[]{'a', 'b', 'c'};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(charArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(char[].class);
+    assertThat(result).isSameAs(charArray);
+  }
+
+  @Test
+  void testWrapperFloatArrayNotConvertedToPCollection() {
+    // Float[] (boxed) should also be excluded for consistency
+    final Float[] floatWrapperArray = new Float[]{1.0f, 2.0f, 3.0f};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(floatWrapperArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(Float[].class);
+    assertThat(result).isSameAs(floatWrapperArray);
+  }
+
+  @Test
+  void testWrapperIntegerArrayNotConvertedToPCollection() {
+    // Integer[] (boxed) should also be excluded for consistency
+    final Integer[] integerWrapperArray = new Integer[]{1, 2, 3};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(integerWrapperArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(Integer[].class);
+    assertThat(result).isSameAs(integerWrapperArray);
+  }
+
+  @Test
+  void testWrapperDoubleArrayNotConvertedToPCollection() {
+    // Double[] (boxed) should also be excluded for consistency
+    final Double[] doubleWrapperArray = new Double[]{1.0, 2.0, 3.0};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(doubleWrapperArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(Double[].class);
+    assertThat(result).isSameAs(doubleWrapperArray);
+  }
+
+  @Test
+  void testWrapperByteArrayNotConvertedToPCollection() {
+    // Byte[] (boxed) should also be excluded (was already excluded before)
+    final Byte[] byteWrapperArray = new Byte[]{1, 2, 3};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(byteWrapperArray);
+
+    // Then: Should return the array as-is, not converted to PCollection
+    assertThat(result).isInstanceOf(Byte[].class);
+    assertThat(result).isSameAs(byteWrapperArray);
+  }
+
+  @Test
+  void testObjectArrayStillConvertedToPCollection() {
+    // String[] should still be converted to PCollection (existing behavior for object arrays)
+    final String[] stringArray = new String[]{"a", "b", "c"};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(stringArray);
+
+    // Then: Should be converted to PCollection, not passed as-is
+    assertThat(result).isInstanceOf(PCollection.class);
+    assertThat(result).isNotSameAs(stringArray);
+  }
+
+  @Test
+  void testEmptyFloatArrayNotConvertedToPCollection() {
+    // Edge case: Empty float array
+    final float[] emptyArray = new float[0];
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(emptyArray);
+
+    // Then: Should return the array as-is
+    assertThat(result).isInstanceOf(float[].class);
+    assertThat(result).isSameAs(emptyArray);
+  }
+
+  @Test
+  void testSingleElementFloatArrayNotConvertedToPCollection() {
+    // Edge case: Single element float array
+    final float[] singleElementArray = new float[]{42.0f};
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(singleElementArray);
+
+    // Then: Should return the array as-is
+    assertThat(result).isInstanceOf(float[].class);
+    assertThat(result).isSameAs(singleElementArray);
+  }
+
+  @Test
+  void testLargeFloatArrayNotConvertedToPCollection() {
+    // Performance test: Large float array (typical vector size)
+    final float[] largeArray = new float[128];
+    for (int i = 0; i < 128; i++) {
+      largeArray[i] = i * 1.0f;
+    }
+    final InputParameter param = new InputParameter(-1);
+
+    // When: Converting to parsed tree
+    final Object result = param.toParsedTree(largeArray);
+
+    // Then: Should return the array as-is (critical for vector performance)
+    assertThat(result).isInstanceOf(float[].class);
+    assertThat(result).isSameAs(largeArray);
+  }
+}
