db

Documentation

Index

• Constants
• type FeatureNotSupportedError
  • func (e *FeatureNotSupportedError) Error() string
• 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) IsRetriable() bool
  • func (e *Neo4jError) IsRetriableCluster() bool
  • func (e *Neo4jError) IsRetriableTransient() bool
  • func (e *Neo4jError) MarkRetriable()
  • func (e *Neo4jError) Title() string
• type Notification
• type Plan
• type ProfiledPlan
• type ProtocolError
  • func (e *ProtocolError) Error() string
• type ProtocolVersion
• type Record
  • func (r Record) Get(key string) (any, bool)
• type StatementType
• type Summary
• 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

Types

type FeatureNotSupportedError

type FeatureNotSupportedError struct {
	Server  string
	Feature string
	Reason  string
}

func (*FeatureNotSupportedError) Error

func (e *FeatureNotSupportedError) Error() string

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
}

Neo4jError is created when the 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) IsRetriable

func (e *Neo4jError) IsRetriable() bool

func (*Neo4jError) IsRetriableCluster

func (e *Neo4jError) IsRetriableCluster() bool

func (*Neo4jError) IsRetriableTransient

func (e *Neo4jError) IsRetriableTransient() bool

func (*Neo4jError) MarkRetriable

func (e *Neo4jError) MarkRetriable()

func (*Neo4jError) Title

func (e *Neo4jError) Title() string

type Notification

type Notification struct {
	Code        string
	Title       string
	Description string
	Position    *InputPosition
	Severity    string
	Category    string
}

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]any
	// 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]any
	// 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
	PageCacheMisses   int64
	PageCacheHits     int64
	PageCacheHitRatio float64
	Time              int64
}

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 ProtocolError

type ProtocolError struct {
	MessageType string
	Field       string
	Err         string
}

func (*ProtocolError) Error

func (e *ProtocolError) Error() string

type ProtocolVersion

type ProtocolVersion struct {
	Major int
	Minor int
}

type Record

type Record struct {
	// Values contains all the values in the record.
	Values []any
	// 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) (any, 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.

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 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
	ContainsSystemUpdates *bool
	ContainsUpdates       *bool
}

type UnsupportedTypeError

type UnsupportedTypeError struct {
	Type reflect.Type
}

func (*UnsupportedTypeError) Error

func (e *UnsupportedTypeError) Error() string