Releases: neo4j/neo4j-java-driver

6.0.1

03 Oct 10:32

@injectives injectives

6.0.1

82f74a1

This commit was created on GitHub.com and signed with GitHub’s verified signature.

GPG key ID: B5690EEEBB952194

Verified

Learn about vigilant mode.

6.0.1 Latest

Latest

The neo4j-java-driver-bom has been updated to not import netty-bom.

If you are using Netty Native Transport, please ensure to either:

Use a compatible Netty Native Transport version with Netty version used by the driver.
Import netty-bom with the desired Netty version (at present, the driver is shipped with Netty 4.2+)

6.0 API documentation

👏 Improvements

feat(bom): delete netty-bom from neo4j-java-driver-bom #1707

Assets 2

6.0.0

01 Oct 15:09

@injectives injectives

6.0.0

f96a053

This commit was created on GitHub.com and signed with GitHub’s verified signature.

GPG key ID: B5690EEEBB952194

Verified

Learn about vigilant mode.

6.0.0

This release brings news features, general improvements and dependency updates.

The sections below describe the main updates in this release and the full changelog is listed in the end.

Java Driver Manual

6.0 API documentation

Neo4j Vector

Neo4j Vector is a new data type introduced in Neo4j server (2025.10, Enterprise Edition).

The driver's type system has been extended to support it.

A new Vector interface represents Neo4j Vector. At present, it has 6 subtypes:

Int8Vector - INTEGER8 vector that has Java byte elements and can be converted to byte[] array
Int16Vector - INTEGER16 vector that has Java short elements and can be converted to short[] array
Int32Vector - INTEGER32 vector that has Java int elements and can be converted to int[] array
Int64Vector - INTEGER vector that has Java long elements and can be converted to long[] array
Float32Vector - FLOAT16 vector that has Java float elements and can be converted to float[] array
Float64Vector - FLOAT vector that has Java double elements and can be converted to double[] array

Similarly to the IsoDuration, new Value instance containing Vector can be created using one of the provided Values#vector(...) factory methods. The Type of such Value is equal to TypeSystem#VECTOR().

Usage example:

var value = Values.vector(new float[] {0.0f});
var result = driver.executableQuery("CREATE (:VectorTest {vector: $vector})")
 .withParameters(Map.of("vector", value))
 .execute();

Since Vector is a sealed interface, it works well with Pattern Matching for switch:

switch (value.asVector()) {
 case Int8Vector int8Vector -> {
 var arr = int8Vector.toArray();
 }
 case Int16Vector int16Vector -> {
 var arr = int16Vector.toArray();
 }
 case Int32Vector int32Vector -> {
 var arr = int32Vector.toArray();
 }
 case Int64Vector int64Vector -> {
 var arr = int64Vector.toArray();
 }
 case Float32Vector float32Vector -> {
 var arr = float32Vector.toArray();
 }
 case Float64Vector float64Vector -> {
 var arr = float64Vector.toArray();
 }
}

Alongside Value#asVector(), it is also possible to map Value to Vector using the Value#as(Class<T>) method. This is especially useful when Vector subtype is well-known:

var vector = value.as(Float32Vector.class);

It is also possible to map to array directly:

var arr = value.as(float[].class);

When using Object Mapping, it is possible to define record components both as Vector and arrays with Vector annotation:

record DomainRecord(
 Float32Vector float32Vector, 
 @Vector float floatArr) {}
var domainRecord = value.as(DomainRecord.class);

Unsupported Type

The Neo4j Vector is a good example of a new type being introduced to the system. It is possible that at some point the driver version connecting to the server might not support a new future type because it requires a newer protocol version to support it.

A new UnsupportedType object has been introduced to identify such types and provide some information about them, like:

name
minimum protocol version
an optional message

The Type of a Value with UnsupportedType is equal to TypeSystem#UNSUPPORTED().

Usage example:

var unsupportedType = value.asUnsupportedType();
System.out.println(unsupportedType.name());
System.out.println(unsupportedType.minProtocolVersion());
unsupportedType.message().ifPresent(System.out::println);

Sending the UnsupportedType back to the server is not supported.

Bill of Materials (BOM)

A new Maven artifact neo4j-java-driver-bom represents driver's Bill of Materials (BOM).

It is especially useful when additional driver dependencies are used.

Usage example (Maven):

<dependencies>
 <dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver</artifactId>
 </dependency>
</dependencies>
<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver-bom</artifactId>
 <type>pom</type>
 <scope>import</scope>
 <version>6.0.0</version>
 </dependency>
 </dependencies>
</dependencyManagement>

The driver BOM also imports netty-bom to ensure compatible versions, especially when Netty Native Transport is used.

Should it be necessary, users can override netty-bom version by importing it before the driver BOM:

<dependencyManagement>
 <dependencies>
 <dependency>
 <groupId>io.netty</groupId>
 <artifactId>netty-bom</artifactId>
 <version>${netty-bom.version}</version>
 <type>pom</type>
 <scope>import</scope>
 </dependency>
 <dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver-bom</artifactId>
 <type>pom</type>
 <scope>import</scope>
 <version>6.0.0</version>
 </dependency>
 </dependencies>
</dependencyManagement>

Query API

NOTE: This feature is in preview.

Neo4j Query API is an HTTP API for executing Cypher statements.

The driver supports connecting to this API over HTTP.

The Query API support is enabled by:

including an extra dependency
using https or http URI scheme

Example (Maven):

<dependencies>
 <dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver</artifactId>
 </dependency>
 <dependency>
 <groupId>org.neo4j.bolt</groupId>
 <artifactId>neo4j-bolt-connection-query-api</artifactId>
 </dependency>
</dependencies>
<dependencyManagement>
 <dependencies>
 <!--> BOM ensures the versions are compatible <-->
 <dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver-bom</artifactId>
 <type>pom</type>
 <scope>import</scope>
 <version>6.0.0</version>
 </dependency>
 </dependencies>
</dependencyManagement>

Driver creation example:

var driver = GraphDatabase.driver("https://query.api.local", authToken);

The are some limitations with this integration at the moment. The main unsuported items are listed below:

Home database resolution.
Records streaming.
- All records are loaded ahead of time to client-side memory. If you deal with large datasets, this integration might need more memory.
Neo4j Vector.
Unsupported Type.
Transaction metadata.
Notification preferences.
ResultSummary#resultAvailableAfter(TimeUnit).
ResultSummary#resultConsumedAfter(TimeUnit).
ResultSummary#queryType().
ResultSummary#plan().
ResultSummary#profile().

Since home database resolution is not supported, the database name MUST be set explicitly using the driver API. Alternatively, it is possible to append the default database name to the URI, it will be used when no database name is set explicitly.

Example: https://query.api.local?defaultDatabase=neo4j

Reducing the number of dependencies

When the driver is used with Query API only, it is possible to exclude some dependencies to reduce the overall amount:

<dependency>
 <groupId>org.neo4j.driver</groupId>
 <artifactId>neo4j-java-driver</artifactId>
 <exclusions>
 <exclusion>
 <groupId>org.neo4j.bolt</groupId>
 <artifactId>neo4j-bolt-connection-netty</artifactId>
 </exclusion>
 </exclusions>
</dependency>

Specifically, this removes the following dependencies:

org.neo4j.bolt:neo4j-bolt-connection-netty
- io.netty:netty-handler
  - io.netty:netty-common
  - io.netty:netty-resolver
  - io.netty:netty-buffer
  - io.netty:netty-transport
  - io.netty:netty-transport-native-unix-common
  - io.netty:netty-codec-base
- io.netty:netty-tcnative-classes

Unix Domain Socket

bolt+unix URI scheme allows connecting to Neo4j server over Unix Domain Socket.

Example:

try (var driver = GraphDatabase.driver("bolt+unix:///var/run/neo4j.sock")) {
 var result = driver.executableQuery("SHOW DATABASES")
 .withConfig(QueryConfig.builder().withDatabase("system").build())
 .execute();
 result.records().forEach(System.out::println);
}

While the driver does not impose any special limitations on such connections, the server has a dedicated purpose for them - administration. Therefore, it limits interations to system database only. See the server configuration settings.