refactor: replace Float[] with float[]

We started off using Float[] and Float[][] because v5 did so
and it was easier to reuse (read: copy-paste) some bits of code.

Thing with object arrays is that they name N allocations (1 for each element)
compared to 1 that a primitive array makes.
That creates unnecessary work for GC and we aren't gaining anything from
using boxed values.

They're still useful for request parameters like distance/certainty/force,
because they can be null. But vectors are not sparse and should never contain
nulls in principle.

Author: bevzzz

src/it/java/io/weaviate/ConcurrentTest.java

@@ -8,6 +8,8 @@
 import org.junit.Rule;
 import org.junit.rules.TestName;
 
+import com.google.common.primitives.Floats;
+
 /**
  * ConcurrentTest is the base class for integration tests, which provides
  * utility methods to uniqualize collections and objects created in the
@@ -56,9 +58,9 @@ protected static String randomUUID() {
    * @param bound  Value range upper bound.
    * @return
    */
-  protected static Float[] randomVector(int length, float origin, float bound) {
-    return IntStream.range(0, length)
+  protected static float[] randomVector(int length, float origin, float bound) {
+    return Floats.toArray(IntStream.range(0, length)
         .<Float>mapToObj(f -> rand.nextFloat(origin, bound))
-        .toArray(Float[]::new);
+        .toList());
   }
 }

src/it/java/io/weaviate/integration/DataITest.java

@@ -37,7 +37,7 @@ public static void beforeAll() throws IOException {
   public void testCreateGetDelete() throws IOException {
     var artists = client.collections.use(COLLECTION);
     var id = randomUUID();
-    Float[] vector = { 1f, 2f, 3f };
+    float[] vector = { 1, 2, 3 };
 
     artists.data.insert(Map.of("name", "john doe"),
         metadata -> metadata
@@ -56,8 +56,8 @@ public void testCreateGetDelete() throws IOException {
           Assertions.assertThat(obj.metadata().uuid())
               .as("object id").isEqualTo(id);
 
-          Assertions.assertThat(obj.metadata().vectors()).extracting(v -> v.getSingle(VECTOR_INDEX))
-              .asInstanceOf(InstanceOfAssertFactories.array(Float[].class)).containsExactly(vector);
+          Assertions.assertThat(obj.metadata().vectors().getSingle(VECTOR_INDEX))
+              .containsExactly(vector);
 
           Assertions.assertThat(obj.properties())
               .as("has expected properties")
@@ -227,7 +227,7 @@ public void testUpdate() throws IOException {
     var authors = client.collections.use(nsAuthors);
     var walter = authors.data.insert(Map.of("name", "walter scott"));
 
-    var vector = new Float[] { 1f, 2f, 3f };
+    var vector = new float[] { 1, 2, 3 };
 
     var books = client.collections.use(nsBooks);
 

src/it/java/io/weaviate/integration/SearchITest.java

@@ -53,7 +53,7 @@ public class SearchITest extends ConcurrentTest {
   /**
    * One of the inserted vectors which will be used as target vector for search.
    */
-  private static Float[] searchVector;
+  private static float[] searchVector;
 
   @BeforeClass
   public static void beforeAll() throws IOException {
@@ -104,8 +104,8 @@ public void testNearVector_groupBy() {
    *
    * @returns IDs of inserted objects and their corresponding vectors.
    */
-  private static Map<String, Float[]> populateTest(int n) throws IOException {
-    var created = new HashMap<String, Float[]>();
+  private static Map<String, float[]> populateTest(int n) throws IOException {
+    var created = new HashMap<String, float[]>();
 
     var things = client.collections.use(COLLECTION);
     for (int i = 0; i < n; i++) {

src/main/java/io/weaviate/client6/v1/api/collections/Vectors.java

@@ -25,21 +25,22 @@
  */
 @ToString
 public class Vectors {
+  /** Elements of this map must only be {@code float[]} or {@code float[][]}. */
   private final Map<String, Object> namedVectors;
 
-  public static Vectors of(Float[] vector) {
-    return new Vectors(VectorIndex.DEFAULT_VECTOR_NAME, vector);
+  public static Vectors of(float[] vector) {
+    return of(VectorIndex.DEFAULT_VECTOR_NAME, vector);
   }
 
-  public static Vectors of(String name, Float[] vector) {
+  public static Vectors of(String name, float[] vector) {
     return new Vectors(name, vector);
   }
 
-  public static Vectors of(Float[][] vector) {
-    return new Vectors(VectorIndex.DEFAULT_VECTOR_NAME, vector);
+  public static Vectors of(float[][] vector) {
+    return of(VectorIndex.DEFAULT_VECTOR_NAME, vector);
   }
 
-  public static Vectors of(String name, Float[][] vector) {
+  public static Vectors of(String name, float[][] vector) {
     return new Vectors(name, vector);
   }
 
@@ -51,33 +52,43 @@ public Vectors(Builder builder) {
     this.namedVectors = builder.namedVectors;
   }
 
-  /*
+  /**
    * Create a single named vector.
-   * Intended to be used by factory methods, which can statically restrict
-   * vector's type to {@code Float[]} and {@code Float[][]}.
    *
-   * @param name Vector name.
-   *
-   * @param vector {@code Float[]} or {@code Float[][]} vector.
+   * <p>
+   * Callers must ensure that vectors are either
+   * {@code float[]} or {@code float[][]}.
    *
+   * @param name   Vector name.
+   * @param vector {@code float[]} or {@code float[][]} vector.
    */
   private Vectors(String name, Object vector) {
     this.namedVectors = Collections.singletonMap(name, vector);
   }
 
+  /**
+   * Create a Vectors from a map.
+   *
+   * <p>
+   * Callers must ensure that vectors are either
+   * {@code float[]} or {@code float[][]}.
+   *
+   * @param name   Vector name.
+   * @param vector Map of named vectors.
+   */
   private Vectors(Map<String, Object> namedVectors) {
     this.namedVectors = namedVectors;
   }
 
   public static class Builder implements ObjectBuilder<Vectors> {
     private final Map<String, Object> namedVectors = new HashMap<>();
 
-    public Builder vector(String name, Float[] vector) {
+    public Builder vector(String name, float[] vector) {
       this.namedVectors.put(name, vector);
       return this;
     }
 
-    public Builder vector(String name, Float[][] vector) {
+    public Builder vector(String name, float[][] vector) {
       this.namedVectors.put(name, vector);
       return this;
     }
@@ -88,22 +99,55 @@ public Vectors build() {
     }
   }
 
-  public Float[] getSingle(String name) {
-    return (Float[]) namedVectors.get(name);
+  /**
+   * Get 1-dimensional vector by name.
+   *
+   * @returns Vector as {@code float[]} or {@code null}.
+   * @throws ClassCastException The underlying vector is not a {@code float[]}.
+   */
+  public float[] getSingle(String name) {
+    return (float[]) namedVectors.get(name);
   }
 
-  public Float[] getDefaultSingle() {
+  /**
+   * Get default 1-dimensional vector.
+   *
+   * @returns Vector as {@code float[]} or {@code null}.
+   * @throws ClassCastException if the underlying object is not a {@code float[]}.
+   */
+  public float[] getDefaultSingle() {
     return getSingle(VectorIndex.DEFAULT_VECTOR_NAME);
   }
 
-  public Float[][] getMulti(String name) {
-    return (Float[][]) namedVectors.get(name);
+  /**
+   * Get 2-dimensional vector by name.
+   *
+   * @returns Vector as {@code float[][]} or {@code null}.
+   * @throws ClassCastException if the underlying object is not a
+   *                            {@code float[][]}.
+   */
+  public float[][] getMulti(String name) {
+    return (float[][]) namedVectors.get(name);
   }
 
-  public Float[][] getDefaultMulti() {
+  /**
+   * Get default 2-dimensional vector.
+   *
+   * @returns Vector as {@code float[][]} or {@code null}.
+   * @throws ClassCastException if the underlying object is not a
+   *                            {@code float[][]}.
+   */
+  public float[][] getDefaultMulti() {
     return getMulti(VectorIndex.DEFAULT_VECTOR_NAME);
   }
 
+  /**
+   * Get all vectors.
+   * Each element is either a {@code float[]} or a {@code float[][]}.
+   *
+   *
+   * @returns Map of name-vector pairs. The returned map is immutable.
+   */
   public Map<String, Object> asMap() {
     return Map.copyOf(namedVectors);
   }
@@ -119,8 +163,8 @@ public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
       }
       final var mapAdapter = gson.getDelegateAdapter(this, new TypeToken<Map<String, Object>>() {
       });
-      final var float_1d = gson.getDelegateAdapter(this, TypeToken.get(Float[].class));
-      final var float_2d = gson.getDelegateAdapter(this, TypeToken.get(Float[][].class));
+      final var float_1d = gson.getDelegateAdapter(this, TypeToken.get(float[].class));
+      final var float_2d = gson.getDelegateAdapter(this, TypeToken.get(float[][].class));
       return (TypeAdapter<T>) new TypeAdapter<Vectors>() {
 
         @Override
@@ -144,6 +188,8 @@ public Vectors read(JsonReader in) throws IOException {
               } else {
                 vector = float_1d.fromJsonTree(array);
               }
+
+              assert (vector instanceof float[]) || (vector instanceof float[][]) : "invalid vector type";
               namedVectors.put(vectorName, vector);
             }
           }

src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java

@@ -72,11 +72,11 @@ public GroupedResponseT hybrid(Hybrid filter, Function<Aggregation.Builder, Obje
 
   // NearVector ---------------------------------------------------------------
 
-  public ResponseT nearVector(Float[] vector, Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn) {
+  public ResponseT nearVector(float[] vector, Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn) {
     return nearVector(NearVector.of(vector), fn);
   }
 
-  public ResponseT nearVector(Float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> nv,
+  public ResponseT nearVector(float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> nv,
       Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn) {
     return nearVector(NearVector.of(vector, nv), fn);
   }
@@ -85,12 +85,12 @@ public ResponseT nearVector(NearVector filter, Function<Aggregation.Builder, Obj
     return performRequest(Aggregation.of(filter, fn));
   }
 
-  public GroupedResponseT nearVector(Float[] vector, Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn,
+  public GroupedResponseT nearVector(float[] vector, Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn,
       GroupBy groupBy) {
     return nearVector(NearVector.of(vector), fn, groupBy);
   }
 
-  public GroupedResponseT nearVector(Float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> nv,
+  public GroupedResponseT nearVector(float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> nv,
       Function<Aggregation.Builder, ObjectBuilder<Aggregation>> fn, GroupBy groupBy) {
     return nearVector(NearVector.of(vector, nv), fn, groupBy);
   }

src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java

@@ -101,10 +101,10 @@ public static <T> void buildObject(WeaviateProtoBatch.BatchObject.Builder object
               var vector = WeaviateProtoBase.Vectors.newBuilder()
                   .setName(entry.getKey());
 
-              if (value instanceof Float[] single) {
+              if (value instanceof float[] single) {
                 vector.setType(VectorType.VECTOR_TYPE_SINGLE_FP32);
                 vector.setVectorBytes(ByteStringUtil.encodeVectorSingle(single));
-              } else if (value instanceof Float[][] multi) {
+              } else if (value instanceof float[][] multi) {
                 vector.setVectorBytes(ByteStringUtil.encodeVectorMulti(multi));
                 vector.setType(VectorType.VECTOR_TYPE_MULTI_FP32);
               }

src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java

@@ -110,23 +110,23 @@ public GroupedResponseT hybrid(Hybrid query, GroupBy groupBy) {
 
   // NearVector queries -------------------------------------------------------
 
-  public ResponseT nearVector(Float[] vector) {
+  public ResponseT nearVector(float[] vector) {
     return nearVector(NearVector.of(vector));
   }
 
-  public ResponseT nearVector(Float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> fn) {
+  public ResponseT nearVector(float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> fn) {
     return nearVector(NearVector.of(vector, fn));
   }
 
   public ResponseT nearVector(NearVector query) {
     return performRequest(query);
   }
 
-  public GroupedResponseT nearVector(Float[] vector, GroupBy groupBy) {
+  public GroupedResponseT nearVector(float[] vector, GroupBy groupBy) {
     return nearVector(NearVector.of(vector), groupBy);
   }
 
-  public GroupedResponseT nearVector(Float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> fn,
+  public GroupedResponseT nearVector(float[] vector, Function<NearVector.Builder, ObjectBuilder<NearVector>> fn,
       GroupBy groupBy) {
     return nearVector(NearVector.of(vector, fn), groupBy);
   }

src/main/java/io/weaviate/client6/v1/api/collections/query/NearVector.java

@@ -10,14 +10,14 @@
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBaseSearch;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
 
-public record NearVector(Float[] vector, Float distance, Float certainty, BaseQueryOptions common)
+public record NearVector(float[] vector, Float distance, Float certainty, BaseQueryOptions common)
     implements QueryOperator, AggregateObjectFilter {
 
-  public static final NearVector of(Float[] vector) {
+  public static final NearVector of(float[] vector) {
     return of(vector, ObjectBuilder.identity());
   }
 
-  public static final NearVector of(Float[] vector, Function<Builder, ObjectBuilder<NearVector>> fn) {
+  public static final NearVector of(float[] vector, Function<Builder, ObjectBuilder<NearVector>> fn) {
     return fn.apply(new Builder(vector)).build();
   }
 
@@ -27,9 +27,9 @@ public NearVector(Builder builder) {
 
   public static class Builder extends BaseVectorSearchBuilder<Builder, NearVector> {
     // Required query parameters.
-    private final Float[] vector;
+    private final float[] vector;
 
-    public Builder(Float[] vector) {
+    public Builder(float[] vector) {
       this.vector = vector;
     }