db

Documentation

Overview

Package db defines generic database functionality.

Index

• Constants
• type AccessMode
• type Command
• type Connection
• type DatabaseSelector
• type InputPosition
• type Neo4jError
  • func (e *Neo4jError) Category() string
  • func (e *Neo4jError) Classification() string
  • func (e *Neo4jError) Error() string
  • func (e *Neo4jError) IsAuthenticationFailed() bool
  • func (e *Neo4jError) IsRetriableCluster() bool
  • func (e *Neo4jError) IsRetriableTransient() bool
  • func (e *Neo4jError) Title() string
• type Notification
• type Plan
• type ProfiledPlan
• type ProtocolVersion
• type Record
  • func (r Record) Get(key string) (interface{}, bool)
  • func (r Record) GetByIndex(i int) interface{}
• type RoutingNotSupportedError
  • func (e *RoutingNotSupportedError) Error() string
• type RoutingTable
• type StatementType
• type StreamHandle
• type Summary
• type TxConfig
• type TxHandle
• type UnsupportedTypeError
  • func (e *UnsupportedTypeError) Error() string

Constants

const (
	NodesCreated         = "nodes-created"
	NodesDeleted         = "nodes-deleted"
	RelationshipsCreated = "relationships-created"
	RelationshipsDeleted = "relationships-deleted"
	PropertiesSet        = "properties-set"
	LabelsAdded          = "labels-added"
	LabelsRemoved        = "labels-removed"
	IndexesAdded         = "indexes-added"
	IndexesRemoved       = "indexes-removed"
	ConstraintsAdded     = "constraints-added"
	ConstraintsRemoved   = "constraints-removed"
	SystemUpdates        = "system-updates"
)

Counter key names

const DefaultDatabase = ""

Marker for using the default database instance.

Types

type AccessMode

type AccessMode int

Definitions of these should correspond to public API

const (
	WriteMode AccessMode = 0
	ReadMode  AccessMode = 1
)

type Command

type Command struct {
	Cypher    string
	Params    map[string]interface{}
	FetchSize int
}

type Connection

type Connection interface {
	TxBegin(txConfig TxConfig) (TxHandle, error)
	TxRollback(tx TxHandle) error
	TxCommit(tx TxHandle) error
	Run(cmd Command, txConfig TxConfig) (StreamHandle, error)
	RunTx(tx TxHandle, cmd Command) (StreamHandle, error)
	// Keys for the specified stream.
	Keys(streamHandle StreamHandle) ([]string, error)
	// Moves to next item in the stream.
	// If error is nil, either Record or Summary has a value, if Record is nil there are no more records.
	// If error is non nil, neither Record or Summary has a value.
	Next(streamHandle StreamHandle) (*Record, *Summary, error)
	// Discards all records on the stream and returns the summary otherwise it will return the error.
	Consume(streamHandle StreamHandle) (*Summary, error)
	// Buffers all records on the stream, records, summary and error will be received through call to Next
	// The Connection implementation should preserve/buffer streams automatically if needed when new
	// streams are created and the server doesn't support multiple streams. Use Buffer to force
	// buffering before calling Reset to get all records and the bookmark.
	Buffer(streamHandle StreamHandle) error
	// Returns bookmark from last committed transaction or last finished auto-commit transaction.
	// Note that if there is an ongoing auto-commit transaction (stream active) the bookmark
	// from that is not included, use Buffer or Consume to end the stream with a bookmark.
	// Empty string if no bookmark.
	Bookmark() string
	// Returns name of the remote server
	ServerName() string
	// Returns server version on pattern Neo4j/1.2.3
	ServerVersion() string
	// Returns true if the connection is fully functional.
	// Implementation of this should be passive, no pinging or similair since it might be
	// called rather frequently.
	IsAlive() bool
	// Returns the point in time when this connection was established.
	Birthdate() time.Time
	// Resets connection to same state as directly after a connect.
	// Active streams will be discarded and the bookmark will be lost.
	Reset()
	ForceReset() error
	// Closes the database connection as well as any underlying connection.
	// The instance should not be used after being closed.
	Close()
	// Gets routing table for specified database name or the default database if
	// database equals DefaultDatabase. If the underlying connection does not support
	// multiple databases, DefaultDatabase should be used as database.
	GetRoutingTable(context map[string]string, bookmarks []string, database string) (*RoutingTable, error)
	// Sets Bolt message logger on already initialized connections
	SetBoltLogger(boltLogger log.BoltLogger)
}

Connection defines an abstract database server connection.

type DatabaseSelector

type DatabaseSelector interface {
	// Should be called immediately after Reset. Not allowed to call multiple times with different
	// databases without a reset inbetween.
	SelectDatabase(database string)
}

If database server connection supports selecting which database instance on the server to connect to. Prior to Neo4j 4 there was only one database per server.

type InputPosition

type InputPosition struct {
	// Offset contains the character offset referred to by this position; offset numbers start at 0.
	Offset int
	// Line contains the line number referred to by this position; line numbers start at 1.
	Line int
	// Column contains the column number referred to by this position; column numbers start at 1.
	Column int
}

InputPosition contains information about a specific position in a statement

type Neo4jError

type Neo4jError struct {
	Code string
	Msg  string
	// contains filtered or unexported fields
}

Database server failed to fulfill request.

func (*Neo4jError) Category

func (e *Neo4jError) Category() string

func (*Neo4jError) Classification

func (e *Neo4jError) Classification() string

func (*Neo4jError) Error

func (e *Neo4jError) Error() string

func (*Neo4jError) IsAuthenticationFailed

func (e *Neo4jError) IsAuthenticationFailed() bool

func (*Neo4jError) IsRetriableCluster

func (e *Neo4jError) IsRetriableCluster() bool

func (*Neo4jError) IsRetriableTransient

func (e *Neo4jError) IsRetriableTransient() bool

func (*Neo4jError) Title

func (e *Neo4jError) Title() string

type Notification

type Notification struct {
	// Code contains a notification code for the discovered issue of this notification.
	Code string
	// Title contains a short summary of this notification.
	Title string
	// Description contains a longer description of this notification.
	Description string
	// Position contains the position in the statement where this notification points to.
	// Not all notifications have a unique position to point to and in that case the position would be set to nil.
	Position *InputPosition
	// Severity contains the severity level of this notification.
	Severity string
}

Notification represents notifications generated when executing a statement. A notification can be visualized in a client pinpointing problems or other information about the statement.

type Plan

type Plan struct {
	// Operator is the operation this plan is performing.
	Operator string
	// Arguments for the operator.
	// Many operators have arguments defining their specific behavior. This map contains those arguments.
	Arguments map[string]interface{}
	// 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
	// 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 []Plan
}

Plan describes the actual plan that the database planner produced and used (or will use) to execute your statement. This can be extremely helpful in understanding what a statement is doing, and how to optimize it. For more details, see the Neo4j Manual. The plan for the statement is a tree of plans - each sub-tree containing zero or more child plans. The statement starts with the root plan. Each sub-plan is of a specific operator, which describes what that part of the plan does - for instance, perform an index lookup or filter results. The Neo4j Manual contains a reference of the available operator types, and these may differ across Neo4j versions.

type ProfiledPlan

type ProfiledPlan struct {
	// Operator contains the operation this plan is performing.
	Operator string
	// Arguments contains the arguments for the operator used.
	// Many operators have arguments defining their specific behavior. This map contains those arguments.
	Arguments map[string]interface{}
	// Identifiers contains 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 contains the number of times this part of the plan touched the underlying data stores/
	DbHits int64
	// Records contains the number of records this part of the plan produced.
	Records int64
	// Children contains 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
}

ProfiledPlan is the same as a regular Plan - except this plan has been executed, meaning it also contains detailed information about how much work each step of the plan incurred on the database.

type ProtocolVersion

type ProtocolVersion struct {
	Major int
	Minor int
}

type Record

type Record struct {
	// Values contains all the values in the record.
	Values []interface{}
	// Keys contains names of the values in the record.
	// Should not be modified. Same instance is used for all records within the same result.
	Keys []string
}

func (Record) Get

func (r Record) Get(key string) (interface{}, bool)

Get returns the value corresponding to the given key along with a boolean that is true if a value was found and false if there were no key with the given name.

If there are a lot of keys in combination with a lot of records to iterate, consider to retrieve values from Values slice directly or make a key -> index map before iterating. This implementation does not make or use a key -> index map since the overhead of making the map might not be beneficial for small and few records.

func (Record) GetByIndex

func (r Record) GetByIndex(i int) interface{}

GetByIndex returns the value in the record at the specified index.

Deprecated: Prefer to access Values directly instead.

type RoutingNotSupportedError

type RoutingNotSupportedError struct {
	Server string
}

func (*RoutingNotSupportedError) Error

func (e *RoutingNotSupportedError) Error() string

type RoutingTable

type RoutingTable struct {
	TimeToLive int
	Routers    []string
	Readers    []string
	Writers    []string
}

type StatementType

type StatementType int

Definitions of these should correspond to public API

const (
	StatementTypeUnknown     StatementType = 0
	StatementTypeRead        StatementType = 1
	StatementTypeReadWrite   StatementType = 2
	StatementTypeWrite       StatementType = 3
	StatementTypeSchemaWrite StatementType = 4
)

type StreamHandle

type StreamHandle interface{}

type Summary

type Summary struct {
	Bookmark      string
	StmntType     StatementType
	ServerName    string
	Agent         string
	Major         int
	Minor         int
	Counters      map[string]int
	TFirst        int64
	TLast         int64
	Plan          *Plan
	ProfiledPlan  *ProfiledPlan
	Notifications []Notification
	Database      string
}

type TxConfig

type TxConfig struct {
	Mode      AccessMode
	Bookmarks []string
	Timeout   time.Duration
	Meta      map[string]interface{}
}

type TxHandle

type TxHandle uint64

type UnsupportedTypeError

type UnsupportedTypeError struct {
	Type reflect.Type
}

func (*UnsupportedTypeError) Error

func (e *UnsupportedTypeError) Error() string