feat(vector): update naming

driver/clirr-ignored-differences.xml

@@ -905,5 +905,41 @@
         <differenceType>8001</differenceType>
     </difference>
 
+    <difference>
+        <className>org/neo4j/driver/types/ByteVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/ShortVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/IntVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/LongVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/FloatVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/DoubleVector</className>
+        <differenceType>8001</differenceType>
+    </difference>
+
+    <difference>
+        <className>org/neo4j/driver/types/Vector</className>
+        <differenceType>7006</differenceType>
+        <method>java.lang.Class elementType()</method>
+        <to>org.neo4j.driver.types.Vector$ElementType</to>
+    </difference>
 
 </differences>

driver/src/main/java/org/neo4j/driver/Value.java

@@ -42,6 +42,7 @@
 import org.neo4j.driver.types.Relationship;
 import org.neo4j.driver.types.Type;
 import org.neo4j.driver.types.TypeSystem;
+import org.neo4j.driver.types.Vector;
 import org.neo4j.driver.util.Immutable;
 import org.neo4j.driver.util.Preview;
 
@@ -679,6 +680,10 @@ public interface Value extends MapAccessor, MapAccessorWithDefaultValue {
      *             <td>{@link TypeSystem#RELATIONSHIP}</td>
      *             <td>{@link Relationship}</td>
      *         </tr>
+     *         <tr>
+     *             <td>{@link TypeSystem#VECTOR}</td>
+     *             <td>{@link Vector}</td>
+     *         </tr>
      *     </tbody>
      * </table>
      *

driver/src/main/java/org/neo4j/driver/Values.java

@@ -43,15 +43,15 @@
 import org.neo4j.driver.exceptions.ClientException;
 import org.neo4j.driver.internal.AsValue;
 import org.neo4j.driver.internal.GqlStatusError;
-import org.neo4j.driver.internal.InternalByteVector;
-import org.neo4j.driver.internal.InternalDoubleVector;
-import org.neo4j.driver.internal.InternalFloatVector;
-import org.neo4j.driver.internal.InternalIntVector;
+import org.neo4j.driver.internal.InternalFloat32Vector;
+import org.neo4j.driver.internal.InternalFloat64Vector;
+import org.neo4j.driver.internal.InternalInt16Vector;
+import org.neo4j.driver.internal.InternalInt32Vector;
+import org.neo4j.driver.internal.InternalInt64Vector;
+import org.neo4j.driver.internal.InternalInt8Vector;
 import org.neo4j.driver.internal.InternalIsoDuration;
-import org.neo4j.driver.internal.InternalLongVector;
 import org.neo4j.driver.internal.InternalPoint2D;
 import org.neo4j.driver.internal.InternalPoint3D;
-import org.neo4j.driver.internal.InternalShortVector;
 import org.neo4j.driver.internal.value.BooleanValue;
 import org.neo4j.driver.internal.value.BytesValue;
 import org.neo4j.driver.internal.value.DateTimeValue;
@@ -1064,7 +1064,7 @@ public static <T> Function<Value, List<T>> ofList(final Function<Value, T> inner
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(byte[] elements) {
-        return value(new InternalByteVector(elements));
+        return value(new InternalInt8Vector(elements));
     }
 
     /**
@@ -1076,7 +1076,7 @@ public static Value vector(byte[] elements) {
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(short[] elements) {
-        return value(new InternalShortVector(elements));
+        return value(new InternalInt16Vector(elements));
     }
 
     /**
@@ -1088,7 +1088,7 @@ public static Value vector(short[] elements) {
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(int[] elements) {
-        return value(new InternalIntVector(elements));
+        return value(new InternalInt32Vector(elements));
     }
 
     /**
@@ -1100,7 +1100,7 @@ public static Value vector(int[] elements) {
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(long[] elements) {
-        return value(new InternalLongVector(elements));
+        return value(new InternalInt64Vector(elements));
     }
 
     /**
@@ -1112,7 +1112,7 @@ public static Value vector(long[] elements) {
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(float[] elements) {
-        return value(new InternalFloatVector(elements));
+        return value(new InternalFloat32Vector(elements));
     }
 
     /**
@@ -1124,7 +1124,7 @@ public static Value vector(float[] elements) {
      */
     @Preview(name = "Neo4j Vector")
     public static Value vector(double[] elements) {
-        return value(new InternalDoubleVector(elements));
+        return value(new InternalFloat64Vector(elements));
     }
 
     private static Value value(Vector vector) {

driver/src/main/java/org/neo4j/driver/internal/AbstractArrayVector.java

@@ -18,6 +18,8 @@
 
 import java.lang.reflect.Array;
 import java.util.Objects;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 import org.neo4j.bolt.connection.values.Vector;
 
 public abstract class AbstractArrayVector<T> implements Vector {
@@ -31,6 +33,7 @@ public abstract class AbstractArrayVector<T> implements Vector {
         this.elements = arraycopy(elements);
     }
 
+    @Override
     public Class<?> elementType() {
         return elementType;
     }
@@ -48,6 +51,10 @@ public Object elements() {
         return elements;
     }
 
+    protected abstract Stream<? extends Number> elementsStream();
+
+    protected abstract String neo4jElementType();
+
     @Override
     public boolean equals(Object o) {
         if (o == null || getClass() != o.getClass()) return false;
@@ -64,10 +71,8 @@ public int hashCode() {
 
     @Override
     public String toString() {
-        return "AbstractArrayVector{" + "elementType="
-                + elementType + ", length="
-                + length + ", elements="
-                + elements + '}';
+        var value = elementsStream().map(Number::toString).collect(Collectors.joining(", ", "[", "]"));
+        return "vector(%s, %d, %s NOT NULL)".formatted(value, length, neo4jElementType());
     }
 
     @SuppressWarnings({"unchecked", "SuspiciousSystemArraycopy"})

driver/src/main/java/org/neo4j/driver/internal/InternalFloat32Vector.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.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.
+ */
+package org.neo4j.driver.internal;
+
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Float32Vector;
+
+public final class InternalFloat32Vector extends AbstractArrayVector<float[]> implements Float32Vector {
+    public InternalFloat32Vector(float[] elements) {
+        super(elements);
+    }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return IntStream.range(0, this.elements.length).mapToObj(i -> this.elements[i]);
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "FLOAT32";
+    }
+}

driver/src/main/java/org/neo4j/driver/internal/InternalFloatVector.java → driver/src/main/java/org/neo4j/driver/internal/InternalFloat64Vector.java

@@ -16,10 +16,22 @@
  */
 package org.neo4j.driver.internal;
 
-import org.neo4j.driver.types.FloatVector;
+import java.util.Arrays;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Float64Vector;
 
-public final class InternalFloatVector extends AbstractArrayVector<float[]> implements FloatVector {
-    public InternalFloatVector(float[] elements) {
+public final class InternalFloat64Vector extends AbstractArrayVector<double[]> implements Float64Vector {
+    public InternalFloat64Vector(double[] elements) {
         super(elements);
     }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return Arrays.stream(elements).boxed();
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "FLOAT";
+    }
 }

driver/src/main/java/org/neo4j/driver/internal/InternalInt16Vector.java

@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [https://neo4j.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.
+ */
+package org.neo4j.driver.internal;
+
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Int16Vector;
+
+public final class InternalInt16Vector extends AbstractArrayVector<short[]> implements Int16Vector {
+    public InternalInt16Vector(short[] elements) {
+        super(elements);
+    }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return IntStream.range(0, this.elements.length).mapToObj(i -> this.elements[i]);
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "INTEGER16";
+    }
+}

driver/src/main/java/org/neo4j/driver/internal/InternalByteVector.java → driver/src/main/java/org/neo4j/driver/internal/InternalInt32Vector.java

@@ -16,10 +16,22 @@
  */
 package org.neo4j.driver.internal;
 
-import org.neo4j.driver.types.ByteVector;
+import java.util.Arrays;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Int32Vector;
 
-public final class InternalByteVector extends AbstractArrayVector<byte[]> implements ByteVector {
-    public InternalByteVector(byte[] elements) {
+public final class InternalInt32Vector extends AbstractArrayVector<int[]> implements Int32Vector {
+    public InternalInt32Vector(int[] elements) {
         super(elements);
     }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return Arrays.stream(elements).boxed();
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "INTEGER32";
+    }
 }

driver/src/main/java/org/neo4j/driver/internal/InternalDoubleVector.java → driver/src/main/java/org/neo4j/driver/internal/InternalInt64Vector.java

@@ -16,10 +16,22 @@
  */
 package org.neo4j.driver.internal;
 
-import org.neo4j.driver.types.DoubleVector;
+import java.util.Arrays;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Int64Vector;
 
-public final class InternalDoubleVector extends AbstractArrayVector<double[]> implements DoubleVector {
-    public InternalDoubleVector(double[] elements) {
+public final class InternalInt64Vector extends AbstractArrayVector<long[]> implements Int64Vector {
+    public InternalInt64Vector(long[] elements) {
         super(elements);
     }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return Arrays.stream(elements).boxed();
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "INTEGER";
+    }
 }

driver/src/main/java/org/neo4j/driver/internal/InternalIntVector.java → driver/src/main/java/org/neo4j/driver/internal/InternalInt8Vector.java

@@ -16,10 +16,22 @@
  */
 package org.neo4j.driver.internal;
 
-import org.neo4j.driver.types.IntVector;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+import org.neo4j.driver.types.Int8Vector;
 
-public final class InternalIntVector extends AbstractArrayVector<int[]> implements IntVector {
-    public InternalIntVector(int[] elements) {
+public final class InternalInt8Vector extends AbstractArrayVector<byte[]> implements Int8Vector {
+    public InternalInt8Vector(byte[] elements) {
         super(elements);
     }
+
+    @Override
+    protected Stream<? extends Number> elementsStream() {
+        return IntStream.range(0, this.elements.length).mapToObj(i -> this.elements[i]);
+    }
+
+    @Override
+    protected String neo4jElementType() {
+        return "INTEGER8";
+    }
 }