go_cypherdsl

type BooleanOperator string

type ConditionBuilder struct {
	Start   *operatorNode
	Current *conditionNode
	// contains filtered or unexported fields
}

type ConditionConfig struct {
	// Either ConditionOperator or ConditionFunction can be set, depending on whether an operator (e.g. '=') is
	// required, or a function (e.g. exists()). Both cannot be specified.
	ConditionOperator BooleanOperator

	//condition functions that can be used
	ConditionFunction string

	// When constructing a conditional, Name must be specified (unless filtering on a Path). Additionally, either
	// Field or Label must be specified (but not both). If Field is specified, FieldManipulationFunction is an
	// optional function that can be specified to manipulate the specified Field during the query. If Label
	// is specified, all other fields (other than Name and NegateCondition) will be ignored.
	Name  string
	Field string // TODO: Rename to `Property` to match OC9 spec
	Label string

	//exclude parentheses
	FieldManipulationFunction string

	// When filtering on a Path, the only other field that can be specified is NegateCondition.
	Path *PathBuilder

	// When using any operator to compare to a specific value (other than InOperator), this field must be specified.
	// If Check and (CheckName, CheckField) are both specified - (CheckName, CheckField) will take precedence.
	Check interface{}

	// When comparing one node to another, CheckField and CheckName must be specified.
	CheckName  string
	CheckField string

	// When using the InOperator, this field must be specified. This will not apply to any other operators.
	CheckSlice []interface{}

	// When NegateCondition is set to true, NOT is appended to the start of this condition to apply a logical
	// negation to the statement.
	NegateCondition bool
}

type ConditionOperator interface {
	And(c *ConditionConfig) ConditionOperator
	AndNested(query WhereQuery, err error) ConditionOperator
	Or(c *ConditionConfig) ConditionOperator
	OrNested(query WhereQuery, err error) ConditionOperator
	Xor(c *ConditionConfig) ConditionOperator
	XorNested(query WhereQuery, err error) ConditionOperator
	Not(c *ConditionConfig) ConditionOperator
	NotNested(query WhereQuery, err error) ConditionOperator
	Build() (WhereQuery, error)
}

type ConstraintConfig struct {
	//specify the name of the variable for the constraint
	Name string

	//specify the type the action takes place on
	Type string

	//specify the field the action takes place on
	Field string

	//require field to be unique
	Unique bool

	//require field to show up
	Exists bool
}

type Create interface {
	Create(CreateQuery, error) Cypher
}

type CreateQuery string

type CustomCypher interface {
	Cypher(q string) Cypher
}

type Cypher interface {
	Match
	OptionalMatch
	Create
	Where
	Merge
	Return
	Delete
	Set
	Remove
	OrderBy
	Limit
	Skip
	With
	Unwind
	Union
	CustomCypher
	QueryCompleter
}

type Cypherize interface {
	ToCypher() (string, error)
}

type Delete interface {
	Delete(detach bool, params ...string) Cypher
}

type DeleteQuery string

type Direction int

type E struct {
	//direction of the edge, if null default to any
	Direction Direction

	//variable name for constraint queries, omit if null
	Name string

	//names in the case that the edge is named or the query could be on multiple edges
	Types []string

	//min jumps to the next node, if null omit
	MinJumps int

	//max jumps to the next node, if null omit
	MaxJumps int

	//params for edges across individual jumps
	Params *Params
}

type EdgeConfig struct {
	Type      string
	StartNode int64
	EndNode   int64
}

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

type FuncString string

type FunctionConfig struct {
	Name   string
	Params []interface{}
}

type IndexConfig struct {
	Type   string
	Fields []string
}

type Limit interface {
	Limit(num int) Cypher
}

type Match interface {
	Match(p *PathBuilder) Cypher
}

type Merge interface {
	Merge(mergeConf *MergeConfig) Cypher
}

type MergeConfig struct {
	// the path its merging on
	Path string

	// what it does if its creating the node
	OnCreate *MergeSetConfig

	// what it does if its matching the node
	OnMatch *MergeSetConfig
}

type MergeQuery string

type MergeSetConfig struct {
	// variable name
	Name string

	// member variable of node
	Member string

	// new value
	Target interface{}

	// new value if its a function, do not include
	TargetFunction *FunctionConfig

	// Operator is the operator used in the SET clause. Must be "=" or "+=".
	// If not set, defaults to "=".
	Operator BooleanOperator
}

type OptionalMatch interface {
	OptionalMatch(p *PathBuilder) Cypher
}

type OrderBy interface {
	OrderBy(orderBys ...OrderByConfig) Cypher
}

type OrderByConfig struct {
	Name   string
	Member string
	Desc   bool
}

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

type ParamString string

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

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

type QueryBuilder struct {
	Start   *queryPartNode
	Current *queryPartNode
	// contains filtered or unexported fields
}

type QueryCompleter interface {
	ToCypher() (string, error)
}

type Remove interface {
	Remove(removes ...RemoveConfig) Cypher
}

type RemoveConfig struct {
	Name   string
	Field  string
	Labels []string
}

type RemoveQuery string

type Return interface {
	Return(distinct bool, parts ...ReturnPart) Cypher
}

type ReturnPart struct {
	Name              string
	Type              string
	Alias             string
	Function          *FunctionConfig
	Literal           interface{}
	BooleanExpression WhereQuery
	Path              string
}

type ReturnQuery string

type Set interface {
	Set(sets ...SetConfig) Cypher
}

type SetConfig struct {
	//name is  required, just the var name
	Name string

	//member is used to set the specific member of a node
	Member string

	//defines whether a variable is being set equal to or mutated
	Operation SetOperation

	//used to set the label of a node, (can give a node many labels)
	Label []string

	//if the target is a literal or a reference to another variable
	Target interface{}

	//if the target is a map
	TargetMap *Params

	//if the target is a function
	TargetFunction *FunctionConfig

	//if the set is being done on a condition
	Condition ConditionOperator
}

type SetOperation string

type SetQuery string

type Skip interface {
	Skip(num int) Cypher
}

type Union interface {
	Union(all bool) Cypher
}

type Unwind interface {
	Unwind(unwind *UnwindConfig) Cypher
}

type UnwindConfig struct {
	Slice []interface{}
	As    string
}

type V struct {
	//name of the vertex, omit if null
	Name string

	//type of edge, omit if null
	Type string

	//params for edge to map to, omit if null
	Params *Params
}

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

type Where interface {
	Where(cb ConditionOperator) Cypher
}

type WhereQuery string

type With interface {
	With(conf *WithConfig) Cypher
}

type WithConfig struct {
	Parts []WithPart
}

type WithPart struct {
	Function *FunctionConfig
	Name     string
	Field    string
	As       string
}