This is the official Neo4j Go Driver.
The Go driver only works with actively maintained Go versions.
Read Go official release policy to learn more.
Make sure your application has been set up to use go modules (there should be a go.mod file in your application root).
Add the driver with:
go get github.com/neo4j/neo4j-go-driver/v5
Add the driver with:
go get github.com/neo4j/neo4j-go-driver/v4
For versions 1.x of the driver (notice the absence of /v4
or /v5
), run instead the following:
go get github.com/neo4j/neo4j-go-driver
Drivers manual that describes general driver concepts in depth here. Go package API documentation here.
The preview feature is a new feature that is a candidate for a future GA status.
It enables users to try the feature out and maintainers to refine and update it.
The preview features are not considered to be experimental, temporary or unstable.
However, they may change more rapidly, without following the usual deprecation cycle.
Most preview features are expected to be granted the GA status unless some unexpected conditions arise.
Due to the increased flexibility of the preview status, user feedback is encouraged so that it can be considered before the GA status.
Every preview feature gets a dedicated GitHub Discussion where users can share their initial impressions and thoughts.
See migration guide for information on how to migrate from previous versions of the driver to the current one.
Connect, execute a statement and handle results
Make sure to use the configuration in the code that matches the version of Neo4j server that you run.
package main
import (
"context"
"fmt"
"github.com/neo4j/neo4j-go-driver/v5/neo4j"
)
func main() {
dbUri := "neo4j://localhost" // scheme://host(:port) (default port is 7687)
driver, err := neo4j.NewDriverWithContext(dbUri, neo4j.BasicAuth("neo4j", "letmein!", ""))
if err != nil {
panic(err)
}
// Starting with 5.0, you can control the execution of most driver APIs
// To keep things simple, we create here a never-cancelling context
// Read https://pkg.go.dev/context to learn more about contexts
ctx := context.Background()
// Handle driver lifetime based on your application lifetime requirements.
// driver's lifetime is usually bound by the application lifetime, which usually implies one driver instance per
// application
defer driver.Close(ctx) // Make sure to handle errors during deferred calls
item, err := insertItem(ctx, driver)
if err != nil {
panic(err)
}
fmt.Printf("%v\n", item)
}
func insertItem(ctx context.Context, driver neo4j.DriverWithContext) (*Item, error) {
result, err := neo4j.ExecuteQuery(ctx, driver,
"CREATE (n:Item { id: $id, name: $name }) RETURN n",
map[string]any{
"id": 1,
"name": "Item 1",
}, neo4j.EagerResultTransformer)
if err != nil {
return nil, err
}
itemNode, _, err := neo4j.GetRecordValue[neo4j.Node](result.Records[0], "n")
if err != nil {
return nil, fmt.Errorf("could not find node n")
}
id, err := neo4j.GetProperty[int64](itemNode, "id")
if err != nil {
return nil, err
}
name, err := neo4j.GetProperty[string](itemNode, "name")
if err != nil {
return nil, err
}
return &Item{Id: id, Name: name}, nil
}
type Item struct {
Id int64
Name string
}
func (i *Item) String() string {
return fmt.Sprintf("Item (id: %d, name: %q)", i.Id, i.Name)
}
Starting with 5.0, the Neo4j Drivers will be moving to a monthly release cadence. A minor version will be released on the last Friday of each month so as to maintain versioning consistency with the core product (Neo4j DBMS) which has also moved to a monthly cadence.
As a policy, patch versions will not be released except on rare occasions. Bug fixes and updates will go into the latest minor version and users should upgrade to that. Driver upgrades within a major version will never contain breaking API changes.
See also: https://neo4j.com/developer/kb/neo4j-supported-versions/
You just need to use neo4j
as the URL scheme and set host of the URL to one of your core members of the cluster.
if driver, err = neo4j.NewDriver("neo4j://localhost:7687", neo4j.BasicAuth("username", "password", "")); err != nil {
return err // handle error
}
There are a few points that need to be highlighted:
- Each
Driver
instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application. - It is considerably cheap to create new sessions and transactions, as sessions and transactions do not create new connections as long as there are free connections available in the connection pool.
- The driver is thread-safe, while the session or the transaction is not thread-safe.
A cypher execution result is comprised of a stream of records followed by a result summary.
The records inside the result can be accessed via Next()
/Record()
functions defined on Result
. It is important to check Err()
after Next()
returning false
to find out whether it is the end of the result stream or an error that caused the end of result consumption.
// Next returns false upon error
for result.Next(ctx) {
record := result.Record()
handleRecord(record)
}
// Err returns the error that caused Next to return false
if err = result.Err(); err != nil {
handleError(err)
}
Values in a Record
can be accessed either by index or by alias. The return value is an any
which means you need
to convert the interface to the expected type
value := record.Values[0]
if value, ok := record.Get('field_name'); ok {
// a value with alias field_name was found
// process value
}
The driver exposes values in the record as an any
type.
The underlying types of the returned values depend on the corresponding Cypher types.
The mapping between Cypher types and the types used by this driver (to represent the Cypher type):
Cypher Type | Driver Type |
---|---|
null | nil |
List | []any |
Map | map[string]any |
Boolean | bool |
Integer | int64 |
Float | float |
String | string |
ByteArray | []byte |
Node | neo4j.Node |
Relationship | neo4j.Relationship |
Path | neo4j.Path |
Cypher Type | Driver Type |
---|---|
Point | neo4j.Point2D |
Point | neo4j.Point3D |
The temporal types are introduced in Neo4j 3.4 series.
You can create a 2-dimensional Point
value using;
point := neo4j.Point2D {X: 1.0, Y: 2.0, SpatialRefId: srId }
or a 3-dimensional point value using;
point := neo4j.Point3D {X: 1.0, Y: 2.0, Z: 3.0, SpatialRefId: srId }
NOTE:
- For a list of supported
srId
values, please refer to the docs here.
The temporal types are introduced in Neo4j 3.4 series. Given the fact that database supports a range of different temporal types, most of them are backed by custom types defined at the driver level.
The mapping among the Cypher temporal types and actual exposed types are as follows:
Cypher Type | Driver Type |
---|---|
Date | neo4j.Date |
Time | neo4j.OffsetTime |
LocalTime | neo4j.LocalTime |
DateTime | time.Time |
LocalDateTime | neo4j.LocalDateTime |
Duration | neo4j.Duration |
Receiving a temporal value as driver type:
dateValue := record.Values[0].(neo4j.Date)
All custom temporal types can be constructed from a time.Time
value using <Type>Of()
(DateOf
, OffsetTimeOf
, ...) functions.
dateValue := DateOf(time.Date(2005, time.December, 16, 0, 0, 0, 0, time.Local)
Converting a custom temporal value into time.Time
(all neo4j
temporal types expose Time()
function to gets its corresponding time.Time
value):
dateValueAsTime := dateValue.Time()
Note:
- When
neo4j.OffsetTime
is converted intotime.Time
or constructed throughOffsetTimeOf(time.Time)
, itsLocation
is given a fixed name ofOffset
(i.e. assignedtime.FixedZone("Offset", offsetTime.offset)
). - When
time.Time
values are sent/received through the driver, if itsZone()
returns a name ofOffset
the value is stored with its offset value and with its zone name otherwise.
Logging at the driver level can be configured by setting Log
field of neo4j.Config
through configuration functions that can be passed to neo4j.NewDriver
function.
For simplicity, we provide a predefined console logger which can be constructed by neo4j.ConsoleLogger
function. To enable console logger, you need to specify which level you need to enable (neo4j.ERROR
, neo4j.WARNING
, neo4j.INFO
and neo4j.DEBUG
which are ordered by the level of detail).
A simple code snippet that will enable console logging is as follows;
useConsoleLogger := func(level neo4j.LogLevel) func(config *neo4j.Config) {
return func(config *neo4j.Config) {
config.Log = neo4j.ConsoleLogger(level)
}
}
// Construct a new driver
if driver, err = neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""), useConsoleLogger(neo4j.ERROR)); err != nil {
return err
}
defer driver.Close()
The Log
field of the neo4j.Config
struct is defined to be of interface neo4j/log.Logger
which has the following definition:
type Logger interface {
Error(name string, id string, err error)
Warnf(name string, id string, msg string, args ...any)
Infof(name string, id string, msg string, args ...any)
Debugf(name string, id string, msg string, args ...any)
}
For a customised logging target, you can implement the above interface and pass an instance of that implementation to the Log
field.
Logging Bolt messages is done at the session level and is configured independently of the logging configuration described above. This is disabled by default.
For simplicity, we provide a predefined console logger which can be constructed by neo4j.ConsoleBoltLogger
.
boltLogger := neo4j.ConsoleBoltLogger()
# for ExecuteQuery
result, err := neo4j.ExecuteQuery(ctx, driver, query, params, transformer, neo4j.ExecuteQueryWithBoltLogger(boltLogger))
# for the regular session APIs (session.Run, session.BeginTransaction, session.ExecuteRead, session.ExecuteWrite)
session := driver.NewSession(neo4j.SessionConfig{BoltLogger: boltLogger})
The BoltLogger
field of the neo4j.SessionConfig
struct is defined to be of interface neo4j/log.BoltLogger
which has the following definition:
type BoltLogger interface {
LogClientMessage(context string, msg string, args ...any)
LogServerMessage(context string, msg string, args ...any)
}
For a customised logging target, you can implement the above interface and pass an instance of that implementation to the BoltLogger
field.
This section describes instructions to use during the development phase of the driver.
The Go driver on this branch requires at least Go 1.18 and relies on Go modules for dependency resolution.
You can run unit tests as follows:
go test -tags internal_testkit,internal_time_mock -short ./...
For these tests, you'll need to start a Neo4j server. This can be done with Neo4j Desktop or with the official Docker image:
docker run --rm \
--env NEO4J_ACCEPT_LICENSE_AGREEMENT=yes \
--env NEO4J_AUTH=neo4j/password \
--publish=7687:7687 \
--health-cmd 'cypher-shell -u neo4j -p password "RETURN 1"' \
--health-interval 5s \
--health-timeout 5s \
--health-retries 5 \
neo4j:4.4-enterprise
Once the server is running, you run integration tests like this:
TEST_NEO4J_HOST="localhost" TEST_NEO4J_VERSION=4.4 \
go test ./neo4j/test-integration/...
Likewise, benchmark tests are run like this:
cd benchmark
go run . neo4j://localhost neo4j password
Tests require the latest Testkit, Python3 and Docker.
Testkit needs to be cloned and configured to run against the Go Driver. Use the following steps to configure it.
- Clone the Testkit repository
git clone https://github.com/neo4j-drivers/testkit.git
- Under the Testkit folder, install the requirements.
pip3 install -r requirements.txt
- Define the following required environment variables
export TEST_DRIVER_NAME=go
export TEST_DRIVER_REPO=<path for the root folder of driver repository>
To run test against some Neo4j version:
python3 main.py
More details about how to use Testkit can be found on its repository