logical

type Aggregate struct {

	// GroupingExpressions are the expressions used
	// in the GROUP BY clause.
	GroupingExpressions []Expression
	// AggregateExpressions are the expressions used
	// in the SELECT clause (e.g. SUM(x), COUNT(y)).
	AggregateExpressions []*IdentifiedExpr
	// Child is the input to the aggregation
	// (e.g. a Project node).
	Child Plan
	// contains filtered or unexported fields
}

type AggregateFunctionCall struct {
	FunctionName string
	Args         []Expression
	Star         bool
	Distinct     bool
	// contains filtered or unexported fields
}

type AliasExpr struct {
	Expr  Expression
	Alias string
}

type AnalyzedPlan struct {
	// Plan is the plan of the query.
	Plan Plan
	// CTEs are plans for the common table expressions in the query.
	// They are in the order that they were defined.
	CTEs []*Subplan
}

type ArithmeticOp struct {
	Left  Expression
	Right Expression
	Op    ArithmeticOperator
}

type ArithmeticOperator uint8

type ArrayAccess struct {
	Array Expression
	Index Expression
}

type ArrayConstructor struct {
	Elements []Expression
}

type Assignment struct {
	// Column is the column to update.
	Column string
	// Value is the value to update the column to.
	Value Expression
}

type CartesianProduct struct {
	Left  Plan
	Right Plan
	// contains filtered or unexported fields
}

type Case struct {
	// Value is the value that is being compared.
	// Can be nil if there is no value to compare.
	Value Expression
	// WhenClauses are the list of when/then pairs.
	// The first element of each pair is the condition,
	// which must match the data type of Value. If Value
	// is nil, the condition must be a boolean.
	WhenClauses [][2]Expression
	// Else is the else clause. Can be nil.
	Else Expression
}

type Collate struct {
	Expr      Expression
	Collation CollationType
}

type CollationType uint8

type ColumnRef struct {
	// Parent relation name, can be empty.
	// If not specified by user, it will be qualified
	// during the planning phase.
	Parent     string
	ColumnName string
	// contains filtered or unexported fields
}

type ComparisonOp struct {
	Left  Expression
	Right Expression
	Op    ComparisonOperator
}

type ComparisonOperator uint8

type ConflictDoNothing struct {

	// ArbiterIndex is the index to use to determine if there is a conflict.
	// If/when Kwil supports partial indexes, we will turn this into a list
	// of indexes. Can be nil when DO NOTHING is used.
	ArbiterIndex Index
	// contains filtered or unexported fields
}

type ConflictResolution interface {
	Plan
	// contains filtered or unexported methods
}

type ConflictUpdate struct {

	// ArbiterIndex is the index to use to determine if there is a conflict.
	// If/when Kwil supports partial indexes, we will turn this into a list
	// of indexes. See: https://github.com/cockroachdb/cockroach/issues/53170
	// Cannot be nil when DO UPDATE is used.
	ArbiterIndex Index
	// Assignments are the expressions to update if there is a conflict.
	// Cannot be nil.
	Assignments []*Assignment
	// ConflictFilter is a predicate that allows us to selectively
	// update or raise an error if there is a conflict.
	// Can be nil.
	ConflictFilter Expression
	// contains filtered or unexported fields
}

type Delete struct {

	// Child is the input to the delete.
	Child Plan
	// Table is the target table name.
	// It will always be the table name and not an alias.
	Table string
	// contains filtered or unexported fields
}

type Distinct struct {
	Child Plan
	// contains filtered or unexported fields
}

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

type ExprRef struct {
	// Identified is the expression that is being referenced.
	// It is a pointer to the actual expression.
	Identified *IdentifiedExpr
}

type Expression interface {
	LogicalNode
	Field() *Field
}

type Field struct {
	Parent string // the parent relation name
	Name   string // the field name

	// ReferenceID is the ID with which this field can be referenced.
	// It can be empty if the field is not referenced.
	ReferenceID string
	// contains filtered or unexported fields
}

type FieldAccess struct {
	Object Expression
	Key    string
}

type Filter struct {
	Condition Expression
	Child     Plan
	// contains filtered or unexported fields
}

type GetObjectFunc = func(objName string) (obj map[string]*types.DataType, err error)

type GetTableFunc = func(namespace string, tableName string) (table *engine.Table, err error)

type GetVarTypeFunc = func(varName string) (dataType *types.DataType, err error)

type IdentifiedExpr struct {
	// ID is the unique identifier for the expression.
	ID string
	// Expr is the expression that is being identified.
	Expr Expression
}

type Index interface {
	fmt.Stringer

	Equal(Index) bool
	// contains filtered or unexported methods
}

type IndexColumnConstraint struct {
	// Table is the physical table that the index is on.
	Table string
	// Column is the column that the constraint is on.
	Column string
	// ConstraintType is the type of constraint that the index is.
	ConstraintType IndexConstraintType
}

type IndexConstraintType uint8

type IndexNamed struct {
	// Name is the name of the index.
	Name string
}

type Insert struct {

	// Table is the physical table to insert into.
	Table string
	// ReferencedAs is how the table is referenced in the query.
	// It is either a user-defined reference or the table name.
	ReferencedAs string
	// Columns are the columns to insert into.
	Columns []*Field
	// InsertionValues are the values to insert.
	// These can be either values specified using VALUES or a subquery.
	InsertionValues Plan
	// ConflictResolution is the conflict resolution to use if there is a conflict.
	ConflictResolution ConflictResolution
	// contains filtered or unexported fields
}

type IsActionFunc = func(funcName string) bool

type IsIn struct {
	// Left is the expression that is being compared.
	Left Expression

	Expressions []Expression
	Subquery    *SubqueryExpr
}

type Join struct {
	Left      Plan
	Right     Plan
	JoinType  JoinType
	Condition Expression
	// contains filtered or unexported fields
}

type JoinType int

type Limit struct {
	Child  Plan
	Limit  Expression
	Offset Expression
	// contains filtered or unexported fields
}

type Literal struct {
	Value interface{}
	Type  *types.DataType
}

type LogicalNode interface {
	fmt.Stringer
	Traversable
}

type LogicalOp struct {
	Left  Expression
	Right Expression
	Op    LogicalOperator
}

type LogicalOperator uint8

type Plan interface {
	LogicalNode
	Relation() *Relation
	// contains filtered or unexported methods
}

type ProcedureScanSource struct {
	// ProcedureName is the name of the procedure being targeted.
	ProcedureName string
	// Args are the base arguments to the procedure.
	Args []Expression
	// ContextualArgs are the arguments that are passed in if
	// the procedure is a foreign procedure.
	ContextualArgs []Expression
	// IsForeign is true if the function is a foreign procedure.
	IsForeign bool
	// contains filtered or unexported fields
}

type Project struct {

	// Expressions are the expressions that are projected.
	Expressions []Expression
	Child       Plan
	// contains filtered or unexported fields
}

type QuerySection string

type Relation struct {
	Fields []*Field
}

type Return struct {

	// Fields are the fields to return.
	Fields []*Field
	// Child is the input to the return.
	Child Plan
	// contains filtered or unexported fields
}

type RewriteConfig struct {
	// ExprCallback is the function that will be called on each expression.
	// It returns the new node, which will replace the old node,
	// a boolean, which indicates whether the nodes children should be visited,
	// and an error, which will be returned if an error occurs.
	ExprCallback func(Expression) (Expression, bool, error)
	// PlanCallback is the function that will be called on each plan
	// It returns the new node, which will replace the old node,
	// a boolean, which indicates whether the nodes children should be visited,
	// and an error, which will be returned if an error occurs.
	PlanCallback func(Plan) (Plan, bool, error)
	// ScanSourceCallback is the function that will be called on each scan source
	// It returns the new node, which will replace the old node,
	// a boolean, which indicates whether the nodes children should be visited,
	// and an error, which will be returned if an error occurs.
	ScanSourceCallback func(ScanSource) (ScanSource, bool, error)
}

type ScalarFunctionCall struct {
	FunctionName string
	Args         []Expression
	// contains filtered or unexported fields
}

type Scan struct {
	Source ScanSource
	// RelationName will always be set.
	// If the scan is a table scan and no alias was specified,
	// the RelationName will be the table name.
	// All other scan types (functions and subqueries) require an alias.
	RelationName string
	// Filter holds the optional filter condition that can be
	// pushed down to the scan operation. This allows filtering data
	// during the scan, which can improve query performance by reducing
	// the amount of data processed in subsequent operations.
	// This field won't ever be set in the initial logical plan, but
	// can be set during the optimization phase.
	Filter Expression
	// contains filtered or unexported fields
}

type ScanSource interface {
	Traversable
	FormatScan() string
	Relation() *Relation
}

type SetOperation struct {
	Left   Plan
	Right  Plan
	OpType SetOperationType
	// contains filtered or unexported fields
}

type SetOperationType int

type Sort struct {
	SortExpressions []*SortExpression
	Child           Plan
	// contains filtered or unexported fields
}

type SortExpression struct {
	Expr      Expression
	Ascending bool
	NullsLast bool
}

type Subplan struct {
	Plan Plan
	ID   string
	Type SubplanType
	// contains filtered or unexported fields
}

type SubplanType int

type Subquery struct {
	// Plan is the logical plan for the subquery.
	Plan *Subplan

	// Correlated is the list of columns that are correlated
	// to the outer query. If empty, the subquery is uncorrelated.
	Correlated []*Field
}

type SubqueryExpr struct {
	Query *Subquery
	// If Exists is true, we are checking if the subquery returns any rows.
	// Otherwise, the subquery will return a single value.
	// If the query is a NOT EXISTS, a unary negation will wrap this expression.
	Exists bool
}

type TableScanSource struct {
	// Namespace is the namespace of the table being scanned.
	Namespace string
	// TableName is the name of the table being scanned.
	TableName string
	Type      TableSourceType
	// contains filtered or unexported fields
}

type TableSourceType int

type TopLevelPlan interface {
	Plan
	// contains filtered or unexported methods
}

type Traversable interface {
	// Children returns the children of the node.
	// These are all LogicalPlans and LogicalExprs that are
	// referenced by the node.
	Children() []Traversable
	// Plans returns all the logical plans that are referenced
	// by the node (or the nearest node that contains them).
	Plans() []Plan
	// Accept is used to traverse the node.
	Accept(Visitor) any
}

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

type TypeCast struct {
	Expr Expression
	Type *types.DataType
}

type UnaryOp struct {
	Expr Expression
	Op   UnaryOperator
}

type UnaryOperator uint8

type Update struct {

	// Child is the input to the update.
	Child Plan
	// Table is the target table name.
	// It will always be the table name and not an alias.
	Table string
	// Assignments are the assignments to update.
	Assignments []*Assignment
	// contains filtered or unexported fields
}

type Variable struct {
	// name is something like $id, @caller, etc.
	VarName string
	// contains filtered or unexported fields
}

type Visitor interface {
	VisitTableScanSource(*TableScanSource) any
	VisitProcedureScanSource(*ProcedureScanSource) any
	VisitSubquery(*Subquery) any
	VisitEmptyScan(*EmptyScan) any
	VisitScan(*Scan) any
	VisitProject(*Project) any
	VisitFilter(*Filter) any
	VisitJoin(*Join) any
	VisitSort(*Sort) any
	VisitLimit(*Limit) any
	VisitDistinct(*Distinct) any
	VisitSetOperation(*SetOperation) any
	VisitAggregate(*Aggregate) any
	VisitWindow(*Window) any
	VisitSubplan(*Subplan) any
	VisitLiteral(*Literal) any
	VisitVariable(*Variable) any
	VisitColumnRef(*ColumnRef) any
	VisitAggregateFunctionCall(*AggregateFunctionCall) any
	VisitScalarFunctionCall(*ScalarFunctionCall) any
	VisitArithmeticOp(*ArithmeticOp) any
	VisitComparisonOp(*ComparisonOp) any
	VisitLogicalOp(*LogicalOp) any
	VisitUnaryOp(*UnaryOp) any
	VisitTypeCast(*TypeCast) any
	VisitAliasExpr(*AliasExpr) any
	VisitArrayAccess(*ArrayAccess) any
	VisitArrayConstructor(*ArrayConstructor) any
	VisitFieldAccess(*FieldAccess) any
	VisitSubqueryExpr(*SubqueryExpr) any
	VisitCollate(*Collate) any
	VisitIsIn(*IsIn) any
	VisitCase(*Case) any
	VisitExprRef(*ExprRef) any
	VisitIdentifiedExpr(*IdentifiedExpr) any
	VisitReturn(*Return) any
	VisitCartesianProduct(*CartesianProduct) any
	VisitUpdate(*Update) any
	VisitDelete(*Delete) any
	VisitInsert(*Insert) any
	VisitConflictDoNothing(*ConflictDoNothing) any
	VisitConflictUpdate(*ConflictUpdate) any
	VisitTuples(*Tuples) any
	VisitWindowFunction(*WindowFunction) any
}

type Window struct {

	// PartitionBy are the expressions used in the PARTITION BY clause.
	PartitionBy []Expression
	// OrderBy are the expressions used in the ORDER BY clause.
	OrderBy []*SortExpression
	// Functions are the window functions that are applied.
	Functions []*IdentifiedExpr
	// Frames are not yet supported, but when they are, they will
	// be added here.
	Child Plan
	// contains filtered or unexported fields
}

type WindowFunction struct {
	// Name is the function being applied.
	Name string
	// Args are the arguments to the function.
	Args []Expression
	// Filter is the optional filter condition that can be applied to the function.
	Filter Expression
	// contains filtered or unexported fields
}