db

package
v5.19.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 2, 2024 License: Apache-2.0 Imports: 3 Imported by: 24

Documentation

Index

Examples

Constants

View Source 
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

Variables

This section is empty.

Functions

This section is empty.

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) HasSecurityCode added in v5.12.0 

func (e *Neo4jError) HasSecurityCode() bool

func (*Neo4jError) IsAuthenticationFailed 

func (e *Neo4jError) IsAuthenticationFailed() bool

func (*Neo4jError) IsRetriable added in v5.8.0 

func (e *Neo4jError) IsRetriable() bool

func (*Neo4jError) IsRetriableCluster 

func (e *Neo4jError) IsRetriableCluster() bool

func (*Neo4jError) IsRetriableTransient 

func (e *Neo4jError) IsRetriableTransient() bool

func (*Neo4jError) MarkRetriable added in v5.8.0 

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) AsMap added in v5.9.0 

func (r Record) AsMap() map[string]any

AsMap returns a dictionary copy made of the record keys and the corresponding values

Example 
record := Record{
	Values: []any{true, 42, "yes"},
	Keys:   []string{"prop1", "prop2", "prop3"},
}

dictionary := record.AsMap()

output, _ := json.Marshal(dictionary)
fmt.Println(string(output))

Output:

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.