Neo4j Go Driver

https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/
Admin
This is the official Neo4j Go Driver, providing functionality to connect and execute statements...
Tokens:56,697
Snippets:695
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### ExecuteQuery configuration callbacks

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Examples of built-in configuration callbacks for ExecuteQuery.

```go
	neo4j.ExecuteQueryWithDatabase
	neo4j.ExecuteQueryWithWritersRouting
 ...
```

--------------------------------

### Connect and Execute Query

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

A minimal example demonstrating how to initialize the driver, execute a Cypher query, and process the results.

```go
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)
}
```

--------------------------------

### Start Neo4j Server via Docker

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Launches a Neo4j enterprise instance for integration testing.

```bash
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
```

--------------------------------

### Get database management queries

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/test-integration/dbserver

Provides queries for creating or dropping databases.

```go
func (s DbServer) CreateDatabaseQuery(db string) string
func (s DbServer) DropDatabaseQuery(db string) string
```

--------------------------------

### Configure Testkit for Acceptance Testing

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Steps to clone, install, and configure the Testkit environment.

```bash
git clone https://github.com/neo4j-drivers/testkit.git
```

```bash
pip3 install -r requirements.txt
```

```bash
export TEST_DRIVER_NAME=go
export TEST_DRIVER_REPO=<path for the root folder of driver repository>
```

```bash
python3 main.py
```

--------------------------------

### Get configuration function

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Returns a function to configure the driver settings.

```go
func (s DbServer) ConfigFunc() func(*config.Config)
```

--------------------------------

### SessionWithContext.BeginTransaction

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Starts a new explicit transaction on the session.

```APIDOC
## BeginTransaction(ctx context.Context, configurers ...func(*TransactionConfig)) (ExplicitTransaction, error)

### Description
Starts a new explicit transaction. The caller is responsible for committing or rolling back the transaction.

### Parameters
- **ctx** (context.Context) - Required - The context for the operation.
- **configurers** (...func(*TransactionConfig)) - Optional - Variadic functions to configure the transaction.
```

--------------------------------

### Get database URI

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Returns the default URI for connecting to the database.

```go
func (s DbServer) URI() string
```

--------------------------------

### Install Neo4j Go Driver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Commands to add the driver to your Go project using go modules.

```bash
go get github.com/neo4j/neo4j-go-driver/v5
```

```bash
go get github.com/neo4j/neo4j-go-driver/v4
```

```bash
go get github.com/neo4j/neo4j-go-driver
```

--------------------------------

### Example output of AsMap

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/db

Shows the JSON representation of a record converted to a map.

```json
{"prop1":true,"prop2":42,"prop3":"yes"}
```

--------------------------------

### Get authentication token

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Returns the default auth token for database connections.

```go
func (s DbServer) AuthToken() neo4j.AuthToken
```

--------------------------------

### Get string representation of Time

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Returns the ISO-8601 compliant string representation of the time.

```go
func (t Time) String() string
```

--------------------------------

### Get and Update RotatingClientCertificateProvider methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/auth

Methods to retrieve the current certificate or update it dynamically.

```go
func (p *RotatingClientCertificateProvider) GetCertificate() *tls.Certificate
```

```go
func (p *RotatingClientCertificateProvider) UpdateCertificate(cert ClientCertificate) error
```

--------------------------------

### Initialize Router

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/router

Creates a new instance of the Router.

```go
func New(rootRouter string, getRouters func() []string, routerContext map[string]string, pool Pool, idlenessTimeout time.Duration, logger log.Logger, logId string) *Router
```

--------------------------------

### Get Relationship ID

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Retrieves the ID of the relationship.

```go
func (r Relationship) GetId() int64
```

--------------------------------

### Get Relationship Properties

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Retrieves the properties map of the relationship.

```go
func (r Relationship) GetProperties() map[string]any
```

--------------------------------

### Create a StaticClientCertificateProvider

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/auth

Initializes a provider that returns a pre-loaded certificate-key pair.

```go
func NewStaticClientCertificateProvider(cert ClientCertificate) (*StaticClientCertificateProvider, error)
```

--------------------------------

### Get Relationship Element ID

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Retrieves the element ID of the relationship.

```go
func (r Relationship) GetElementId() string
```

--------------------------------

### NewServer Function

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/pool

Creates a new server instance.

```go
func NewServer() *server
```

--------------------------------

### Initialize Neo4j Driver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Establishes a connection to a Neo4j database using a URI and authentication credentials.

```go
driver, err = NewDriverWithContext("neo4j://core.db.server:7687", BasicAuth(username, password))
```

```go
driver, err = NewDriverWithContext(uri, BasicAuth(username, password), function (config *Config) {
	config.MaxConnectionPoolSize = 10
})
```

--------------------------------

### Initialize DriverWithContext

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Create a new driver instance using the required Bolt URI and authentication credentials.

```go
func NewDriverWithContext(target string, auth auth.TokenManager, configurers ...func(*Config)) (DriverWithContext, error)
```

```go
driver, err = NewDriverWithContext("bolt://db.server:7687", BasicAuth(username, password))
```

--------------------------------

### Get Bolt URI

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Retrieves the Bolt protocol URI for the server.

```go
func (s DbServer) BoltURI() string
```

--------------------------------

### func (Record) Get

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/db

Retrieves the value associated with a specific key from a record.

```APIDOC
## func (Record) Get

### Description
Returns the value corresponding to the given key along with a boolean indicating if the key was found.

### Signature
`func (r Record) Get(key string) (any, bool)`

### Parameters
- **key** (string) - The key to look up in the record.

### Returns
- **value** (any) - The value associated with the key, if found.
- **found** (bool) - True if the key exists in the record, false otherwise.
```

--------------------------------

### Retrieve DbServer instance

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Fetches the database server configuration for integration tests.

```go
func GetDbServer(ctx context.Context) DbServer
```

--------------------------------

### Get transaction workloads query

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Retrieves the query string for transaction workloads.

```go
func (s DbServer) GetTransactionWorkloadsQuery() string
```

--------------------------------

### Connect to a database server

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/connector

The Connect method establishes a connection to the specified address using the provided authentication and logging parameters.

```go
func (c *Connector) Connect(
	ctx context.Context,
	address string,
	auth *db.ReAuthToken,
	errorListener bolt.ConnectionErrorListener,
	boltLogger log.BoltLogger,
) (connection db.Connection, err error)
```

--------------------------------

### Create driver instance

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Creates a new Neo4j driver instance with optional configuration.

```go
func (s DbServer) Driver(configurers ...func(*config.Config)) neo4j.DriverWithContext
```

--------------------------------

### Get string representation of Point3D

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Returns the string representation of the 3D point.

```go
func (p Point3D) String() string
```

--------------------------------

### Initialize a new Cache

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/homedb

Creates a new cache instance with a specified maximum size.

```go
func NewCache(maxSize int) (*Cache, error)
```

--------------------------------

### Get string representation of Point2D

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Returns the string representation of the 2D point.

```go
func (p Point2D) String() string
```

--------------------------------

### Initialize Neo4j Driver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Functions for creating a new driver instance for single instance or cluster connections.

```go
func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Driver, error)
```

```go
driver, err = NewDriver("bolt://db.server:7687", BasicAuth(username, password))
```

```go
driver, err = NewDriver("neo4j://core.db.server:7687", BasicAuth(username, password))
```

--------------------------------

### Run Integration and Benchmark Tests

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Commands to execute integration tests and benchmark suites.

```bash
TEST_NEO4J_HOST="localhost" TEST_NEO4J_VERSION=4.4 \
  go test ./neo4j/test-integration/...
```

```bash
cd benchmark
go run . neo4j://localhost neo4j password
```

--------------------------------

### Define Time structure

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Represents time since the start of the day with timezone information.

```go
type Time time.Time // Time since start of day with timezone information
```

--------------------------------

### Define LocalTime type

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Represents time since the start of the day in a local timezone.

```go
type LocalTime time.Time // Time since start of day in local timezone
```

--------------------------------

### NewDriverWithContext

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Initializes a new Neo4j driver instance. This is the entry point for establishing a connection to a Neo4j database.

```APIDOC
## func NewDriverWithContext

### Description
Creates an instance of a Driver. It is the first function to be called in order to establish a connection to a neo4j database. It requires a Bolt URI and authentication as parameters and can also take optional configuration function(s) as variadic parameters.

### Signature
`func NewDriverWithContext(target string, auth auth.TokenManager, configurers ...func(*Config)) (DriverWithContext, error)`

### Parameters
- **target** (string) - Required - The Bolt URI (e.g., 'bolt://db.server:7687').
- **auth** (auth.TokenManager) - Required - Authentication information.
- **configurers** (...func(*Config)) - Optional - Variadic configuration functions.
```

--------------------------------

### Create database query

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Generates a query string to create a database.

```go
func (s DbServer) CreateDatabaseQuery(db string) string
```

--------------------------------

### ExecuteQuery with combined configuration

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Combining multiple built-in configuration callbacks when calling ExecuteQuery.

```go
ExecuteQuery[T](ctx, driver, query, params, transformerFunc,
	neo4j.ExecuteQueryWithDatabase("my-db"),
	neo4j.ExecuteQueryWithWritersRouting())
```

--------------------------------

### Create Bookmarks from Raw Values

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Utility function to create a Bookmarks instance from raw server-side bookmark strings.

```go
func BookmarksFromRawValues(values ...string) Bookmarks
```

--------------------------------

### Retrieve database routing information

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/internal/router

Methods to get the default database name or update reader/writer lists.

```go
func (r *Router) GetNameOfDefaultDatabase(ctx context.Context, bookmarks []string, user string, auth *idb.ReAuthToken, boltLogger log.BoltLogger) (string, error)
func (r *Router) GetOrUpdateReaders(
	ctx context.Context,
	bookmarks func(context.Context) ([]string, error),
	dbSelection idb.DatabaseSelection,
	auth *idb.ReAuthToken,
	boltLogger log.BoltLogger,
	onRoutingTableUpdated func(string),
) ([]string, error)
func (r *Router) GetOrUpdateWriters(
	ctx context.Context,
	bookmarks func(context.Context) ([]string, error),
	dbSelection idb.DatabaseSelection,
	auth *idb.ReAuthToken,
	boltLogger log.BoltLogger,
	onRoutingTableUpdated func(string),
) ([]string, error)
```

--------------------------------

### NewDriverWithContext

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Initializes a new Neo4j driver instance with the specified URI and authentication token.

```APIDOC
## func NewDriverWithContext

### Description
Creates a new driver instance to connect to a Neo4j database or cluster.

### Signature
func NewDriverWithContext(uri string, auth AuthToken, configurers ...func(*Config)) (DriverWithContext, error)

### Parameters
- **uri** (string) - Required - The connection URI (e.g., neo4j://host:7687).
- **auth** (AuthToken) - Required - Authentication token (e.g., BasicAuth, KerberosAuth).
- **configurers** (...func(*Config)) - Optional - Configuration functions to override default settings.
```

--------------------------------

### ExecuteQuery with custom configuration

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Defining a custom configuration callback for granular control over ExecuteQuery settings.

```go
ExecuteQuery[T](ctx, driver, query, params, transformerFunc, func(config *neo4j.ExecuteQueryConfiguration) {
	config.Database = "my-db"
	config.RoutingControl = neo4j.Write
	config.ImpersonatedUser = "selda_bağcan"
})
```

--------------------------------

### Create Version from string

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Parses a version string into a Version object.

```go
func VersionOf(server string) Version
```

--------------------------------

### Initialize a new Set

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/collections

Creates a new Set instance containing the provided values.

```go
func NewSet[T comparable](values []T) Set[T]
```

--------------------------------

### New Pool Constructor

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/pool

Initializes a new connection pool with the provided configuration and dependencies.

```go
func New(config *config.Config, connect Connect, logger log.Logger, logId string, cache *homedb.Cache) *Pool
```

--------------------------------

### Create a BasicTokenManager

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/auth

Generates a manager for basic authentication password rotation, triggered by server rejection.

```go
func BasicTokenManager(provider authTokenProvider) TokenManager
```

--------------------------------

### ServerInfo Interface

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Provides basic information about the connected server.

```go
type ServerInfo interface {
	// Address returns the address of the server.
	Address() string
	Agent() string
	ProtocolVersion() db.ProtocolVersion
}
```

--------------------------------

### Router Lifecycle and Context

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/router

Methods for cleaning up resources and retrieving router context.

```go
func (r *Router) CleanUp()
func (r *Router) Context() map[string]string
```

--------------------------------

### Manual session transaction implementation

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Replicating ExecuteQuery functionality using sessions and transaction functions manually.

```go
// all the error handling bits have been omitted for brevity (do not do this in production!)
session := driver.NewSession(ctx, neo4j.SessionConfig{
	DatabaseName:     "<DATABASE>",
	ImpersonatedUser: "<USER>",
	BookmarkManager:  bookmarkManager,
})
defer handleClose(ctx, session)
// session.ExecuteRead is called if the routing is set to neo4j.Read
result, _ := session.ExecuteWrite(ctx, func(tx neo4j.ManagedTransaction) (any, error) {
	result, _ := tx.Run(ctx, "<CYPHER>", parameters)
	records, _ := result.Collect(ctx) // real implementation does not use Collect
	keys, _ := result.Keys()
	summary, _ := result.Consume(ctx)
	return &neo4j.EagerResult{
		Keys:    keys,
		Records: records,
		Summary: summary,
	}, nil
})
eagerResult := result.(*neo4j.EagerResult)
// do something with eagerResult
```

--------------------------------

### Define Path Alias

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Alias for dbtype.Path.

```go
type Path = dbtype.Path
```

--------------------------------

### Convert Bookmarks to Raw Values

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Exposes raw server-side bookmarks for serialization purposes.

```go
func BookmarksToRawValues(bookmarks Bookmarks) []string
```

--------------------------------

### Connect Function

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/bolt

Initiates Bolt protocol negotiation and returns a connection instance.

```go
func Connect(ctx context.Context,
	serverName string,
	conn net.Conn,
	auth *db.ReAuthToken,
	userAgent string,
	routingContext map[string]string,
	errorListener ConnectionErrorListener,
	logger log.Logger,
	boltLogger log.BoltLogger,
	notificationConfig db.NotificationConfig,
	readBufferSize int,
) (db.Connection, error)
```

--------------------------------

### Define Version struct

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Represents the version of the database server.

```go
type Version struct {
	// contains filtered or unexported fields
}
```

--------------------------------

### Define Default Database Constant

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/internal/db

Use this constant to represent the default database instance.

```go
const DefaultDatabase = ""
```

--------------------------------

### Date String and Time methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Methods for converting Date to ISO-8601 strings or standard time.Time objects.

```go
func (t Date) String() string
```

```go
func (t Date) Time() time.Time
```

--------------------------------

### Initialize BoltAgent

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/boltagent

Creates a new BoltAgent instance with preformatted driver information.

```go
func New() *BoltAgent
```

--------------------------------

### Define BookmarkManagerConfig

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Configuration structure for managing bookmarks, including initial bookmarks and supplier/consumer hooks.

```go
type BookmarkManagerConfig struct {
	// Initial bookmarks per database
	InitialBookmarks Bookmarks

	// Supplier providing external bookmarks
	BookmarkSupplier func(context.Context) (Bookmarks, error)

	// Hook called whenever bookmarks get updated
	// The hook is called with the database and the new bookmarks
	// Note: the order of the supplied bookmark slice is not guaranteed
	BookmarkConsumer func(ctx context.Context, bookmarks Bookmarks) error
}
```

--------------------------------

### RouterFake Methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/testutil

Methods for interacting with the RouterFake mock object.

```go
func (r *RouterFake) CleanUp()
```

```go
func (r *RouterFake) GetNameOfDefaultDatabase(_ context.Context, _ []string, user string, _ *db.ReAuthToken, _ log.BoltLogger) (string, error)
```

```go
func (r *RouterFake) GetOrUpdateReaders(
	_ context.Context,
	bookmarksFn func(context.Context) ([]string, error),
	dbSelection db.DatabaseSelection,
	_ *db.ReAuthToken,
	_ log.BoltLogger,
	_ func(string),
) ([]string, error)
```

```go
func (r *RouterFake) GetOrUpdateWriters(
	_ context.Context,
	bookmarksFn func(context.Context) ([]string, error),
	dbSelection db.DatabaseSelection,
	_ *db.ReAuthToken,
	_ log.BoltLogger,
	_ func(string),
) ([]string, error)
```

```go
func (r *RouterFake) Invalidate(database string)
```

```go
func (r *RouterFake) InvalidateReader(database string, server string)
```

```go
func (r *RouterFake) InvalidateServer(server string)
```

```go
func (r *RouterFake) InvalidateWriter(database string, server string)
```

```go
func (r *RouterFake) Readers(string) []string
```

```go
func (r *RouterFake) Writers(string) []string
```

--------------------------------

### ConnFake Connection Methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/testutil

Methods for managing the lifecycle and state of the mock connection.

```go
func (c *ConnFake) Birthdate() time.Time
```

```go
func (c *ConnFake) Bookmark() string
```

```go
func (c *ConnFake) Buffer(context.Context, idb.StreamHandle) error
```

```go
func (c *ConnFake) Close(ctx context.Context)
```

```go
func (c *ConnFake) ConnId() string
```

```go
func (c *ConnFake) Connect(
	context.Context,
	int,
	*idb.ReAuthToken,
	string,
	map[string]string,
	idb.NotificationConfig,
) error
```

```go
func (c *ConnFake) Consume(context.Context, idb.StreamHandle) (*db.Summary, error)
```

```go
func (c *ConnFake) Database() string
```

```go
func (c *ConnFake) ForceReset(context.Context)
```

```go
func (c *ConnFake) GetCurrentAuth() (auth.TokenManager, iauth.Token)
```

```go
func (c *ConnFake) GetRoutingTable(_ context.Context, _ map[string]string, _ []string, database, _ string) (*idb.RoutingTable, error)
```

```go
func (c *ConnFake) HasFailed() bool
```

```go
func (c *ConnFake) IdleDate() time.Time
```

```go
func (c *ConnFake) IsAlive() bool
```

```go
func (c *ConnFake) IsSsrEnabled() bool
```

```go
func (c *ConnFake) Keys(idb.StreamHandle) ([]string, error)
```

```go
func (c *ConnFake) Next(context.Context, idb.StreamHandle) (*db.Record, *db.Summary, error)
```

```go
func (c *ConnFake) ReAuth(ctx context.Context, token *idb.ReAuthToken) error
```

```go
func (c *ConnFake) Reset(context.Context)
```

```go
func (c *ConnFake) ResetAuth()
```

```go
func (c *ConnFake) Run(_ context.Context, _ idb.Command, txConfig idb.TxConfig) (idb.StreamHandle, error)
```

```go
func (c *ConnFake) RunTx(context.Context, idb.TxHandle, idb.Command) (idb.StreamHandle, error)
```

```go
func (c *ConnFake) SelectDatabase(database string)
```

```go
func (c *ConnFake) ServerName() string
```

```go
func (c *ConnFake) ServerVersion() string
```

```go
func (c *ConnFake) SetBoltLogger(log.BoltLogger)
```

```go
func (c *ConnFake) SetPinHomeDatabaseCallback(callback func(ctx context.Context, database string))
```

```go
func (c *ConnFake) Telemetry(telemetry.API, func())
```

```go
func (c *ConnFake) TxBegin(_ context.Context, txConfig idb.TxConfig, syncMessages bool) (idb.TxHandle, error)
```

```go
func (c *ConnFake) TxCommit(context.Context, idb.TxHandle) error
```

```go
func (c *ConnFake) TxRollback(context.Context, idb.TxHandle) error
```

```go
func (c *ConnFake) Version() db.ProtocolVersion
```

--------------------------------

### Pool Return Method

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/pool

Returns a connection to the pool.

```go
func (p *Pool) Return(ctx context.Context, c idb.Connection)
```

--------------------------------

### Create Console Logger

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/log

Returns a logger that outputs to stdout, filtering by the specified minimum log level.

```go
func ToConsole(level Level) Logger
```

--------------------------------

### Connector.Connect

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/internal/connector

Establishes a new connection to the database server using the provided context, address, authentication token, and logging/error listeners.

```APIDOC
## func (*Connector) Connect

### Description
Establishes a connection to a database server.

### Signature
func (c *Connector) Connect(ctx context.Context, address string, auth *db.ReAuthToken, errorListener bolt.ConnectionErrorListener, boltLogger log.BoltLogger) (connection db.Connection, err error)

### Parameters
- **ctx** (context.Context) - The context for the connection operation.
- **address** (string) - The address of the database server.
- **auth** (*db.ReAuthToken) - The authentication token.
- **errorListener** (bolt.ConnectionErrorListener) - Listener for connection errors.
- **boltLogger** (log.BoltLogger) - Logger for Bolt protocol events.

### Returns
- **connection** (db.Connection) - The established database connection.
- **err** (error) - An error object if the connection fails.
```

--------------------------------

### Bookmark Manager Interface

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Interface for centralizing bookmark tracking and notification across sessions.

```go
type BookmarkManager interface {
	// UpdateBookmarks updates the bookmark tracked by this bookmark manager
	// previousBookmarks are the initial bookmarks of the bookmark holder (like a Session)
	// newBookmarks are the bookmarks that are received after completion of the bookmark holder operation (like the end of a Session)
	UpdateBookmarks(ctx context.Context, previousBookmarks, newBookmarks Bookmarks) error

	// GetBookmarks returns all the bookmarks tracked by this bookmark manager
	// Note: the order of the returned bookmark slice does not need to be deterministic
	GetBookmarks(ctx context.Context) (Bookmarks, error)
}
```

```go
func NewBookmarkManager(config BookmarkManagerConfig) BookmarkManager
```

--------------------------------

### Configure ExecuteQuery without BookmarkManager

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Use this function to configure ExecuteQuery to operate without relying on a BookmarkManager.

```go
func ExecuteQueryWithoutBookmarkManager() ExecuteQueryConfigurationOption
```

--------------------------------

### Type Aliases

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Aliases for common database types to simplify imports.

```go
type InvalidValue = dbtype.InvalidValue
```

```go
type LocalDateTime = dbtype.LocalDateTime
```

```go
type LocalTime = dbtype.LocalTime
```

```go
type Node = dbtype.Node
```

--------------------------------

### Compare versions

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Methods to compare version objects.

```go
func (version Version) Equals(other Version) bool
```

```go
func (version Version) GreaterThan(other Version) bool
```

```go
func (version Version) GreaterThanOrEqual(other Version) bool
```

```go
func (version Version) LessThan(other Version) bool
```

```go
func (version Version) LessThanOrEqual(other Version) bool
```

```go
func (version Version) String() string
```

--------------------------------

### Run Unit Tests

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Executes unit tests with specific build tags.

```bash
go test -tags internal_neo4j_go_driver_testkit,internal_neo4j_go_driver_time_mock -short ./...
```

--------------------------------

### NewDriver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Creates a new instance of a Driver to establish a connection to a Neo4j database. This is the entry point for the driver.

```APIDOC
## func NewDriver(target string, auth AuthToken, configurers ...func(*Config)) (Driver, error)

### Description
NewDriver is the entry point to the neo4j driver to create an instance of a Driver. It requires a Bolt URI and an authentication token as parameters and can also take optional configuration function(s) as variadic parameters.

### Parameters
- **target** (string) - Required - The Bolt URI (e.g., bolt://db.server:7687 or neo4j://core.db.server:7687)
- **auth** (AuthToken) - Required - The authentication token
- **configurers** (...func(*Config)) - Optional - Variadic configuration functions

### Request Example
driver, err = NewDriver("bolt://db.server:7687", BasicAuth(username, password))
```

--------------------------------

### Define SessionConfig struct

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Configuration structure for initializing a new session with the Neo4j driver.

```go
type SessionConfig struct {
	// AccessMode used when using Session.Run and explicit transactions. Used to route query
	// to read or write servers when running in a cluster. Session.ReadTransaction and Session.WriteTransaction
	// does not rely on this mode.
	AccessMode AccessMode
	// Bookmarks are the initial bookmarks used to ensure that the executing server is at least up
	// to date to the point represented by the latest of the provided bookmarks. After running commands
	// on the session the bookmark can be retrieved with Session.LastBookmark. All commands executing
	// within the same session will automatically use the bookmark from the previous command in the
	// session.
	Bookmarks Bookmarks
	// DatabaseName sets the target database name for the queries executed within the session created with this
	// configuration.
	// Usage of Cypher clauses like USE is not a replacement for this option.
	// Drive r sends Cypher to the server for processing.
	// This option has no explicit value by default, but it is recommended to set one if the target database is known
	// in advance. This has the benefit of ensuring a consistent target database name throughout the session in a
	// straightforward way and potentially simplifies driver logic as well as reduces network communication resulting
	// in better performance.
	// When no explicit name is set, the driver behavior depends on the connection URI scheme supplied to the driver on
	// instantiation and Bolt protocol version.
	//
	// Specifically, the following applies:
	//
	// - for bolt schemes
	//		queries are dispatched to the server for execution without explicit database name supplied,
	// 		meaning that the target database name for query execution is determined by the server.
	//		It is important to note that the target database may change (even within the same session), for instance if the
	//		user's home database is changed on the server.
	//
	// - for neo4j schemes
	//		providing that Bolt protocol version 4.4, which was introduced with Neo4j server 4.4, or above
	//		is available, the driver fetches the user's home database name from the server on first query execution
	//		within the session and uses the fetched database name explicitly for all queries executed within the session.
	//		This ensures that the database name remains consistent within the given session. For instance, if the user's
	//		home database name is 'movies' and the server supplies it to the driver upon database name fetching for the
	//		session, all queries within that session are executed with the explicit database name 'movies' supplied.
	//		Any change to the user’s home database is reflected only in sessions created after such change takes effect.
	//		This behavior requires additional network communication.
	//		In clustered environments, it is strongly recommended to avoid a single point of failure.
	//		For instance, by ensuring that the connection URI resolves to multiple endpoints.
	//		For older Bolt protocol versions, the behavior is the same as described for the bolt schemes above.
	DatabaseName string
	// FetchSize defines how many records to pull from server in each batch.
	// From Bolt protocol v4 (Neo4j 4+) records can be fetched in batches as
	// compared to fetching all in previous versions.
	// If the underlying protocol does not support FetchSize, it is ignored.
	//
	// If FetchSize is set to `FetchDefault`, the driver decides the appropriate size.
	// If set to a positive value that size is used; negative values behaves as `FetchAll` (see below).
	//
	// To turn off fetching in batches and always fetch everything, set FetchSize to `FetchAll`.
	// A limited FetchSize ensures the client is not overflown with records,
	// and allows to bound memory usage.
	FetchSize int
	// Logging target the session will send its Bolt message traces
	//
	// Possible to use custom logger (implement log.BoltLogger interface) or
	// use neo4j.ConsoleBoltLogger.
	BoltLogger log.BoltLogger
	// ImpersonatedUser sets the Neo4j user that the session will be acting as.
	// If not set, the user configured for the driver will be used.
	//
	// If user impersonation is used, the default database for that impersonated
	// user will be used unless DatabaseName is set.
	//
	// In the former case, when routing is enabled, using impersonation
	// without DatabaseName will cause the driver to query the
	// cluster for the name of the default database of the impersonated user.
	// This is done at the beginning of the session so that queries are routed
	// to the correct cluster member (different databases may have different
	// leaders).
	ImpersonatedUser string
}
```

--------------------------------

### Create RotatingClientCertificateProvider

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/auth

Constructor for a provider that allows dynamic certificate rotation.

```go
func NewRotatingClientCertificateProvider(cert ClientCertificate) (*RotatingClientCertificateProvider, error)
```

--------------------------------

### Cache.Get

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/homedb

Retrieves the home database for a given user from the cache.

```APIDOC
## func (c *Cache) Get(user string) (string, bool)

### Description
Retrieves the home database for a given user, if it exists. It updates the lastUsed timestamp for the entry.
```

--------------------------------

### Define DbServer struct

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Represents the configuration and metadata for a database server instance.

```go
type DbServer struct {
	Username     string
	Password     string
	Scheme       string
	Hostname     string
	Port         int
	IsCluster    bool
	IsEnterprise bool
	Version      Version
}
```

--------------------------------

### Define ExecuteQueryConfiguration Struct

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Holds configuration settings for executing queries via neo4j.ExecuteQuery.

```go
type ExecuteQueryConfiguration struct {
	Routing                RoutingControl
	ImpersonatedUser       string
	Database               string
	BookmarkManager        BookmarkManager
	BoltLogger             log.BoltLogger
	TransactionConfigurers []func(*TransactionConfig)
	Auth                   *AuthToken
}
```

--------------------------------

### Define OffsetTime and Path Aliases

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Type aliases for database types to simplify imports and maintain compatibility.

```go
type OffsetTime = dbtype.Time
```

```go
type Path = dbtype.Path
```

--------------------------------

### PoolFull type and methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j/internal/errorutil

Error type for full connection pools.

```go
type PoolFull struct {
	Servers []string
}
```

```go
func (e *PoolFull) Error() string
```

--------------------------------

### Define TxConfig structure

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/db

Configuration parameters for transaction execution, including access mode, bookmarks, and timeouts.

```go
type TxConfig struct {
	Mode               AccessMode
	Bookmarks          []string
	Timeout            time.Duration
	ImpersonatedUser   string
	Meta               map[string]any
	NotificationConfig NotificationConfig
}
```

--------------------------------

### Driver.NewSession

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Creates a new session based on the specified session configuration.

```APIDOC
## NewSession(config SessionConfig) Session

### Description
Creates a new session based on the specified session configuration.

### Parameters
- **config** (SessionConfig) - Required - The configuration for the new session
```

--------------------------------

### Configure Console Logging for Neo4j Driver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5

Enables console logging by passing a configuration function to the driver constructor.

```go
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()
```

--------------------------------

### Session Interface

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Defines the session interface for executing transactions and managing bookmarks.

```go
type Session interface {
	// LastBookmarks returns the bookmark received following the last successfully completed transaction.
	// If no bookmark was received or if this transaction was rolled back, the initial set of bookmarks will be
	// returned.
	LastBookmarks() Bookmarks
	// LastBookmark returns the bookmark received following the last successfully completed transaction.
	// If no bookmark was received or if this transaction was rolled back, the bookmark value will not be changed.
	// Warning: this method can lead to unexpected behaviour if the session has not yet successfully completed a
	// transaction.
	//
	// Deprecated: since version 5.0. Will be removed in 6.0. Use LastBookmarks instead.
	LastBookmark() string
	// BeginTransaction starts a new explicit transaction on this session
	BeginTransaction(configurers ...func(*TransactionConfig)) (Transaction, error)
	// ReadTransaction executes the given unit of work in a AccessModeRead transaction with
	// retry logic in place
	ReadTransaction(work TransactionWork, configurers ...func(*TransactionConfig)) (any, error)
	// WriteTransaction executes the given unit of work in a AccessModeWrite transaction with
	// retry logic in place
	WriteTransaction(work TransactionWork, configurers ...func(*TransactionConfig)) (any, error)
	// Run executes an auto-commit statement and returns a result
	Run(cypher string, params map[string]any, configurers ...func(*TransactionConfig)) (Result, error)
	// Close closes any open resources and marks this session as unusable
	Close() error
}
```

--------------------------------

### Configure ExecuteQuery Options

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Functions to configure specific aspects of the ExecuteQuery execution, such as auth, logging, routing, and database targeting.

```go
func ExecuteQueryWithAuthToken(auth AuthToken) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithBoltLogger(boltLogger log.BoltLogger) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithBookmarkManager(bookmarkManager BookmarkManager) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithDatabase(db string) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithImpersonatedUser(user string) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithReadersRouting() ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithTransactionConfig(configurers ...func(*TransactionConfig)) ExecuteQueryConfigurationOption
```

```go
func ExecuteQueryWithWritersRouting() ExecuteQueryConfigurationOption
```

--------------------------------

### New

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/boltagent

Creates and returns a new BoltAgent instance containing immutable, preformatted driver information.

```APIDOC
## func New()

### Description
Returns a new BoltAgent instance containing immutable, preformatted driver information.

### Signature
`func New() *BoltAgent`
```

--------------------------------

### Create Duration Instance

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Constructs a neo4j.Duration from specific time components.

```go
func DurationOf(months, days, seconds int64, nanos int) Duration
```

--------------------------------

### LocalTime methods

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/dbtype

Methods for converting LocalTime to strings or time.Time objects.

```go
func (t LocalTime) String() string
```

```go
func (t LocalTime) Time() time.Time
```

--------------------------------

### Drop database query

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/test-integration/dbserver

Generates a query string to drop a database.

```go
func (s DbServer) DropDatabaseQuery(db string) string
```

--------------------------------

### Combine Multiple Bookmarks

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Helper function to merge multiple Bookmarks instances into one, useful for chaining sessions.

```go
func CombineBookmarks(bookmarks ...Bookmarks) Bookmarks
```

```go
s4 := driver.NewSession(neo4j.SessionConfig{
	Bookmarks: neo4j.CombineBookmarks(s1.LastBookmarks(), s2.LastBookmarks(), s3.LastBookmarks()),
})
```

--------------------------------

### Create a new default diagnostic record

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/gql

Initializes a new diagnostic record as a map of string keys to arbitrary values.

```go
func NewDefaultDiagnosticRecord() map[string]any
```

--------------------------------

### Retrieve Record Values with GetRecordValue

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Demonstrates how to extract values from a record using a specific type, handling missing keys and null values.

```go
// the above query has been executed, `result` holds the cursor over the person nodes
for result.Next() {
	record := result.Record()
	name, isNil, err := neo4j.GetRecordValue[string](record, "name")
	// for the person with the non-blank name, name == "Arya", isNil == false, err == nil
	// for the person with the blank name, name == "", isNil == false, err == nil
	// for the node without name, name == "", isNil == true, err == nil

	_, _, err := neo4j.GetRecordValue[string](record, "invalid-key")
	// this results in an error, since "invalid-key" is not part of the query result keys
}
```

--------------------------------

### Create LocalDateTime from time.Time

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Converts a standard Go time.Time to a neo4j.LocalDateTime.

```go
func LocalDateTimeOf(t time.Time) LocalDateTime
```

--------------------------------

### Define DatabaseSelection structure

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/db

Encapsulates the database name and a flag indicating if it is a guessed home database.

```go
type DatabaseSelection struct {
	Name          string
	IsHomeDbGuess bool
}
```

--------------------------------

### Pool Cleanup Method

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/pool

Prunes old connections from all servers in the pool.

```go
func (p *Pool) CleanUp(ctx context.Context)
```

--------------------------------

### Retrieve a cache entry

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/homedb

Fetches the home database for a specific user and updates the entry's last-used timestamp.

```go
func (c *Cache) Get(user string) (string, bool)
```

--------------------------------

### Accessing the Now variable

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/time

Provides a reference to the standard time.Now function.

```go
var Now = time.Now
```

--------------------------------

### User Agent Constant

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Defines the driver user agent string using the current version.

```go
const UserAgent = "Go Driver/" + metadata.DriverVersion
```

--------------------------------

### Define ProfiledPlan interface

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Extends the Plan interface with execution metrics such as database hits, record counts, and cache performance.

```go
type ProfiledPlan interface {
	// Operator returns the operation this plan is performing.
	Operator() string
	// Arguments returns the arguments for the operator used.
	// Many operators have arguments defining their specific behavior. This map contains those arguments.
	Arguments() map[string]any
	// Identifiers returns a list of identifiers used by this plan. Identifiers used by this part of the plan.
	// These can be both identifiers introduced by you, or automatically generated.
	Identifiers() []string
	// DbHits returns the number of times this part of the plan touched the underlying data stores/
	DbHits() int64
	// Records returns the number of records this part of the plan produced.
	Records() int64
	// Children returns zero or more child plans. A plan is a tree, where each child is another plan.
	// The children are where this part of the plan gets its input records - unless this is an operator that
	// introduces new records on its own.
	Children() []ProfiledPlan
	PageCacheMisses() int64
	PageCacheHits() int64
	PageCacheHitRatio() float64
	Time() int64
}
```

--------------------------------

### Configure Neo4j Driver

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5/neo4j

Overrides default driver configuration settings using a configuration function.

```go
driver, err = NewDriverWithContext(uri, BasicAuth(username, password), function (config *Config) {
	config.MaxConnectionPoolSize = 10
})
```

--------------------------------

### Borrow Connection Method

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j/internal/pool

Retrieves a connection from the pool, optionally waiting if none are available.

```go
func (p *Pool) Borrow(
	ctx context.Context,
	getServerNames func() []string,
	wait bool,
	boltLogger log.BoltLogger,
	idlenessTimeout time.Duration,
	auth *idb.ReAuthToken,
) (idb.Connection, error)
```

--------------------------------

### Create LocalTime from time.Time

Source: https://pkg.go.dev/github.com/neo4j/neo4j-go-driver/v5%40v5.28.4/neo4j

Converts a standard Go time.Time to a neo4j.LocalTime.

```go
func LocalTimeOf(t time.Time) LocalTime
```
Tokens:
Raw