db

type AccessMode int

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

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.
	// If user impersonation is used (impersonatedUser != "") and default database is used
	// the database name in the returned routing table will contain the actual name of the
	// configured default database for the impersonated user. If no impersonation is used
	// database name in routing table will be set to the name of the requested database.
	GetRoutingTable(context map[string]string, bookmarks []string, database, impersonatedUser string) (*RoutingTable, error)
	// Sets Bolt message logger on already initialized connections
	SetBoltLogger(boltLogger log.BoltLogger)
}

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

type FeatureNotSupportedError struct {
	Server  string
	Feature string
	Reason  string
}

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
}

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

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
}

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
}

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

type ProtocolError struct {
	MessageType string
	Field       string
	Err         string
}

type ProtocolVersion struct {
	Major int
	Minor int
}

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
}

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

type StatementType int

type StreamHandle interface{}

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 TxConfig struct {
	Mode             AccessMode
	Bookmarks        []string
	Timeout          time.Duration
	ImpersonatedUser string
	Meta             map[string]interface{}
}

type TxHandle uint64

type UnsupportedTypeError struct {
	Type reflect.Type
}