neoutils

type AutoConnectTransactional struct {
	// contains filtered or unexported fields
}

type BatchCypherRunner struct {
	// contains filtered or unexported fields
}

type ConnectionConfig struct {
	// BatchSize controls how and whether to batch multiple requests to
	// CypherQuery into a single batch. BatchSize 0 disables this behaviour.
	// Values >0 indicate the largest preferred batch size.  Actual sizes
	// may be larger because values from a single call will never be split.
	BatchSize int
	// Transactional indicates that the connection should use the
	// transactional endpoints in the neo4j REST API.
	Transactional bool
	// Optionally a custom http.Client can be supplied
	HTTPClient *http.Client
	// BackgroundConnect indicates that NeoConnection should be available when
	// neo4j is not available, and will connect and re-connect as required.
	BackgroundConnect bool
}

type ConstraintViolationError struct {
	Msg string
	Err error
}

type CypherQuery struct {
	// used by Neo4j HTTP API
	Statement  string                 `json:"statement"`
	Parameters map[string]interface{} `json:"parameters"`

	// Used by neoism, for compatibility purposes
	Result interface{} `json:"-"`
}

type CypherRunner interface {
	CypherBatch(queries []*CypherQuery) error
}

type Database interface {
	// CreateIndex starts a background job in the database that will create and
	// populate the new index of a specified property on nodes of a given label.
	CreateIndex(label, propertyName string) error

	// Indexes lists indexes for a label.  If a blank string is given as the label,
	// returns all indexes.
	Indexes(label string) ([]Index, error)

	// UniqueConstraints get a specific unique constraint for a label and a property.
	// If a blank string is given as the property, return all unique constraints for
	// the label.
	UniqueConstraints(label, propertyName string) ([]UniqueConstraint, error)

	// CreateUniqueConstraint create a unique constraint on a property on nodes
	// with a specific label.
	CreateUniqueConstraint(label, propertyName string) error

	CypherBatch(queries []*CypherQuery) error

	String() string
}

type DefaultNeoConnection struct {
	// contains filtered or unexported fields
}

type Index struct {
	Name       string
	Label      string
	Properties []string
}

type IndexEnsurer interface {
	EnsureConstraints(indexes map[string]string) error
	EnsureIndexes(indexes map[string]string) error
}

type IndexManager interface {
	CreateIndex(label string, propertyName string) error
	Indexes(label string) ([]Index, error)
	CreateUniqueConstraint(label string, propertyName string) error
	UniqueConstraints(label string, propertyName string) ([]UniqueConstraint, error)
}

type NeoConnection interface {
	CypherRunner
	IndexEnsurer
}

type NeoError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

type NeoErrors []NeoError

type NeoObject map[string]interface{}

type NeoResponse struct {
	Results []NeoResult `json:"results"`
	Errors  NeoErrors   `json:"errors"`
}

type NeoResult struct {
	Columns []string `json:"columns"`
	Data    []Record `json:"data"`
}

type Payload struct {
	Statements []*CypherQuery `json:"statements"`
}

type QueryResult []NeoObject

type Record struct {
	Row []interface{} `json:"row"`
}

type Session struct {
	Client *http.Client
	Log    bool // Log request and response

	// Optional
	Userinfo *url.Userinfo

	// Optional defaults - can be overridden in a Request
	Header *http.Header
	Params *url.Values

	CommitTxEndpoint string
}

type StringerDb struct{ Database }

type TransactionalCypherRunner struct{ DB Database }

type UniqueConstraint struct {
	Name       string
	Label      string
	Type       string
	Properties []string
}