opencypher

type AddOrSubtractExpression struct {
	Add []MultiplyDivideModuloExpression
	Sub []MultiplyDivideModuloExpression
	// contains filtered or unexported fields
}

type AndExpression struct {
	Parts []Evaluatable
}

type Atom interface {
	Evaluatable
}

type BooleanLiteral bool

type Case struct {
	Test         Expression
	Alternatives []CaseAlternative
	Default      Expression
}

type CaseAlternative struct {
	When Expression
	Then Expression
}

type ComparisonExpression struct {
	First  Expression
	Second []PartialComparisonExpression
}

type CountAtom struct{}

type DoubleLiteral float64

type ErrInvalidExpression string

type ErrInvalidFunctionCall struct {
	Msg string
}

type ErrInvalidValueReferenceInPattern struct {
	Symbol string
}

type ErrSyntax string

type ErrUnknownFunction struct {
	Name string
}

type ErrUnknownParameter struct {
	Key string
}

type ErrUnknownVariable struct {
	Name string
}

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

type Evaluatable interface {
	Evaluate(*EvalContext) (Value, error)
}

type Expression interface {
	Evaluatable
}

type Filter struct {
}

type FilterAtom struct {
	Op     string
	Filter FilterExpression
}

type FilterExpression struct {
	Variable Variable
	InExpr   Expression
	Where    Expression
}

type Function func(*EvalContext, []Evaluatable) (Value, error)

type FunctionInvocation struct {
	Name     []SymbolicName
	Distinct bool
	Args     []Expression
	// contains filtered or unexported fields
}

type IntLiteral int

type ListComprehension struct {
	Filter FilterExpression
	Expr   Expression
}

type ListLiteral struct {
	Values []Expression
	// contains filtered or unexported fields
}

type ListRangeExpression struct {
	First  Expression
	Second Expression
}

type MapKeyValue struct {
	Key   string
	Value Expression
}

type MapLiteral struct {
	KeyValues []MapKeyValue
	// contains filtered or unexported fields
}

type Match struct {
	Optional bool
	Pattern  Pattern
	Where    Expression
}

type MultiPartQuery struct {
	Parts       []MultiPartQueryPart
	SingleQuery SinglePartQuery
}

type MultiPartQueryPart struct {
	Read   []ReadingClause
	Update []UpdatingClause
	With   WithClause
}

type MultiplyDivideModuloExpression struct {
	Parts []MultiplyDivideModuloExpressionPart
	// contains filtered or unexported fields
}

type MultiplyDivideModuloExpressionPart struct {
	// For the first element of parts, Op=0
	Op   rune
	Expr PowerOfExpression
}

type NodeLabels []SchemaName

type NodePattern struct {
	Var        *Variable
	Labels     *NodeLabels
	Properties *Properties
}

type NotExpression struct {
	Part ComparisonExpression
}

type NullLiteral struct{}

type OrExpression struct {
	Parts []Evaluatable
}

type Order struct {
	Items []SortItem
}

type Parameter string

type PartialComparisonExpression struct {
	Op   string
	Expr AddOrSubtractExpression
}

type Pattern struct {
	Parts []PatternPart
}

type PatternChain struct {
	Rel  RelationshipPattern
	Node NodePattern
}

type PatternComprehension struct {
	Var   *Variable
	Rel   RelationshipsPattern
	Where Expression
	Expr  Expression
}

type PatternPart struct {
	Var   *Variable
	Start NodePattern
	Path  []PatternChain
}

type PowerOfExpression struct {
	Parts []UnaryAddOrSubtractExpression
	// contains filtered or unexported fields
}

type ProjectionBody struct {
	Distinct bool
	Items    ProjectionItems
	Order    *Order
	Skip     Expression
	Limit    Expression
}

type ProjectionItem struct {
	Var  *Variable
	Expr Expression
}

type ProjectionItems struct {
	All   bool
	Items []ProjectionItem
}

type Properties struct {
	Map   *MapLiteral
	Param *Parameter
}

type PropertyOrLabelsExpression struct {
	Atom           Atom
	PropertyLookup []SchemaName
	NodeLabels     *NodeLabels
}

type RangeLiteral struct {
	From, To *IntLiteral
}

type ReadingClause interface {
	GetResults(*EvalContext) (ResultSet, error)
}

type RegularQuery struct {
	SingleQuery Evaluatable
	Unions      []Union
}

type RelationshipPattern struct {
	Backwards  bool
	Var        *Variable
	RelTypes   *RelationshipTypes
	Range      *RangeLiteral
	Properties *Properties
}

type RelationshipTypes struct {
	Rel []SchemaName
}

type RelationshipsPattern struct {
	Start NodePattern
	Chain []PatternChain
}

type ReservedWord string

type ResultSet struct {
	Nodes graph.NodeSet
	Edges graph.EdgeSet

	Rows []map[string]Value
}

type ReturnClause struct {
	Projection ProjectionBody
}

type SchemaName struct {
	*SymbolicName
	*ReservedWord
}

type SinglePartQuery struct {
	Read   []ReadingClause
	Update []UpdatingClause
	Return *ReturnClause
}

type SortItem struct {
	Asc  bool
	Expr Expression
}

type StringListNullOperatorExpression struct {
	PropertyOrLabels PropertyOrLabelsExpression
	Parts            []StringListNullOperatorExpressionPart
}

type StringListNullOperatorExpressionPart struct {
	String    *StringOperatorExpression
	ListIn    Expression
	ListIndex Expression
	ListRange *ListRangeExpression
	IsNull    *bool
}

type StringLiteral string

type StringOperatorExpression struct {
	Operator string
	Expr     Expression
}

type SymbolicName string

type UnaryAddOrSubtractExpression struct {
	Neg  bool
	Expr StringListNullOperatorExpression
	// contains filtered or unexported fields
}

type Union struct {
	All         bool
	SingleQuery Evaluatable
}

type Unwind struct {
	Expr Expression
	As   Variable
}

type UpdatingClause interface {
	Evaluatable
}

type Value struct {
	Value    interface{}
	Constant bool
}

type Variable SymbolicName

type WithClause struct {
	Projection ProjectionBody
	Where      Expression
}

type XorExpression struct {
	Parts []Evaluatable
}