querycore

type Adjustment struct {
	Field    FieldRef
	Bind     func() (driver.Value, error)
	Subtract bool
}

type AggregateCast uint8

type AggregateFilter struct{ Predicates []Expression }

type AggregateKind uint8

type AggregateNode struct {
	Sensitive bool
	Kind      AggregateKind
	Field     FieldRef
	Cast      AggregateCast
	Filter    *AggregateFilter
}

type AssignmentValue struct {
	Bind      func() (driver.Value, error)
	Value     *InputState // Private type erasure; metadata checks the exact V before mutation.
	CopyValue func() any
}

type BinaryComparison struct {
	Text        bool
	Left, Right ValueExpression
	Operator    Operator
}

type CaseBranch struct {
	Condition Expression
	Result    ValueExpression
}

type CaseNode struct {
	Branches  []CaseBranch
	Otherwise ValueExpression
	Err       error
}

type Column struct {
	Name            string
	Nullable        bool
	DatabaseDefault bool
	Encrypted       bool
}

type Comparison struct {
	Operand ValueExpression
	Values  *ComparisonValuesState
	Bind    func(any) (driver.Value, error)

	// Text is supplied by text-capable builders, never inferred from a string codec.
	Text     bool
	Operator Operator
	// Kind is the operand codec's scalar representation. Membership tests over
	// supported scalar kinds bind one array parameter instead of one per value.
	Kind codec.ParameterType
	// contains filtered or unexported fields
}

type ComparisonValuesState = comparisonValuesState

type CompiledKey struct {
	Node        ValueExpression
	Grouped     bool
	Sql         string
	ArgumentEnd int
	Rendering   bool
}

type Compiler struct {
	AllowLocks    bool
	LockWork      int
	Ctes          map[string]*CteNode
	Self          *RecursiveReference
	DirectSelf    bool
	InWindow      bool
	IndexTarget   bool
	Outer         *OuterScope
	Keys          *SelectKeys
	FieldObserver func(int, FieldRef)
	Arguments     []any
	Columns       map[string]Column
	Sources       map[string]map[string]Column
	// scopeContext is the executing call's context; it resolves context
	// global scopes, including those lowered from related queries.
	ScopeContext                              context.Context
	ScopeShapeOnly                            bool
	SelectDepth, SelectNodes, ExpressionNodes int
	ValueDepth                                int
	ScalarSQLBytes                            int
	// contains filtered or unexported fields
}

type ComputedOrder struct{ Expression ValueExpression }

type ConditionalKind uint8

type ConditionalNode struct {
	Kind      ConditionalKind
	Arguments []ValueExpression
	Err       error
}

type Conflict struct {
	Keys                                     []ValueExpression
	Constraint                               string
	Named                                    bool
	Action                                   ConflictAction
	Updates                                  []ConflictUpdate
	Condition, RowCondition, TargetCondition []Expression
}

type ConflictAction uint8

type ConflictUpdate struct {
	Field          FieldRef
	Literal        *AssignmentValue
	MutatedLiteral bool
	Incoming, Null bool
	Value          ValueExpression
}

type CteMaterialization uint8

type CteNode struct {
	Name            string
	Query           SelectNode
	Columns         []Column
	Materialization CteMaterialization
	Recursion       *RecursiveCTE
}

type Cursor[M any] struct {
	// contains filtered or unexported fields
}

type CursorBoundary struct {
	Keys              []driver.Value
	Backward, Present bool
}

type CursorEnvelope struct {
	Version int           `json:"v"`
	Scope   string        `json:"scope"`
	Values  []CursorValue `json:"values"`
}

type CursorField struct {
	Sensitive bool
	Decode    func(any) (driver.Value, error)
}

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

type CursorPage[M any] struct {
	Items          []M
	Size           int
	Next, Previous value.Optional[Cursor[M]]
}

type CursorRequest[M any] struct {
	Size          int
	After, Before value.Optional[Cursor[M]]
}

type CursorValue = sqlvalue.Value

type DistinctKind uint8

type DistinctOrder struct {
	Index    ValueIndex
	Ordinals []int
}

type DistinctSpec struct {
	Kind DistinctKind
	Keys []ValueExpression
}

type Expression interface{ ExpressionNode() }

type FieldMutator struct {
	Column        string
	Input, Output reflect.Type
	Apply         func(AssignmentValue) (AssignmentValue, error)
}

type FieldRef struct{ Table, Column string }

type FrameBound struct {
	Kind     FrameBoundKind
	Offset   *OffsetState
	Distance *RangeDistance
}

type FrameBoundKind uint8

type FrameExclusion uint8

type FrameKind uint8

type GlobalScopeName string

type InputState = inputState

type JoinKind uint8

type JoinNode struct {
	Source  TableSource
	On      Expression
	Kind    JoinKind
	Lateral *ScopeRequirement
}

type JoinedNode struct {
	Node    SelectNode
	Aliases map[string]reflect.Type
	Err     error
}

type Junction struct {
	Any      bool
	Children []Expression
}

type LazyScopes struct {
	Source func() []ScopeDefinition
	Once   sync.Once
	Ready  atomic.Bool
	Scopes []ScopeDefinition
	Err    error
}

type LiteralState = literalState

type LockBehavior uint8

type LockSpec struct {
	Strength LockStrength
	Behavior LockBehavior
	Targets  []string
	// nil targets means all eligible sources; an explicitly empty Of is invalid.
	Explicit bool
}

type LockStrength uint8

type LookupDefault struct {
	Column string
	Value  driver.Value
}

type ModelDefinition struct {
	Sensitive      map[string]bool
	Table, Primary string
	Columns        []Column
	Timestamps     *TimestampColumns
	SoftDelete     *SoftDeleteColumn
	GlobalScopes   []ScopeDefinition
	ScopeSource    *LazyScopes
}

type MutationAssignment struct {
	Field FieldRef
	AssignmentValue
	// seal encrypts an encrypted field's plaintext for its row before binding.
	Seal Sealer
}

type MutationKind uint8

type NamedWindow struct {
	Name       string
	Definition WindowSpec
}

type Negation struct{ Child Expression }

type NullPlacement uint8

type OffsetState = offsetState

type OperationArgument struct {
	Value ValueExpression
	Kind  codec.ParameterType
}

type OperationNode struct {
	Kind      ScalarOperation
	Arguments []OperationArgument
	Result    codec.ParameterType
	Err       error
}

type OperationSpec struct {
	Name     string
	Min, Max int
	Infix    bool
}

type Operator uint8

type OrderNode struct {
	Expression ValueExpression
	Descending bool
	Nulls      NullPlacement
}

type OuterScope struct {
	Sources map[string]map[string]Column
	Field   func(FieldRef) error
}

type Page[M any] struct {
	Items        []M
	Number, Size int
	Total, Pages int64
}

type PageRequest struct{ Number, Size int }

type ParameterNode struct {
	Sensitive bool
	Kind      codec.ParameterType
	Value     *LiteralState
	Err       error
	// literal renders a generated declaration constant, such as a JSON
	// property name, inline as an escaped schema literal instead of a bind
	// parameter, so expression indexes on the same path can match. Values
	// supplied at run time always remain bind parameters.
	Literal bool
}

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

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

type PlanEnvelope struct {
	Plan          PlanNode                `json:"Plan"`
	PlanningTime  value.Optional[float64] `json:"Planning Time,omitzero"`
	ExecutionTime value.Optional[float64] `json:"Execution Time,omitzero"`
}

type PlanNode struct {
	NodeType           string                  `json:"Node Type"`
	ParentRelationship string                  `json:"Parent Relationship,omitempty"`
	RelationName       string                  `json:"Relation Name,omitempty"`
	Schema             string                  `json:"Schema,omitempty"`
	Alias              string                  `json:"Alias,omitempty"`
	IndexName          string                  `json:"Index Name,omitempty"`
	JoinType           string                  `json:"Join Type,omitempty"`
	Strategy           string                  `json:"Strategy,omitempty"`
	ParallelAware      bool                    `json:"Parallel Aware"`
	StartupCost        float64                 `json:"Startup Cost"`
	TotalCost          float64                 `json:"Total Cost"`
	PlanRows           float64                 `json:"Plan Rows"`
	PlanWidth          int64                   `json:"Plan Width"`
	ActualStartupTime  value.Optional[float64] `json:"Actual Startup Time,omitzero"`
	ActualTotalTime    value.Optional[float64] `json:"Actual Total Time,omitzero"`
	ActualRows         value.Optional[float64] `json:"Actual Rows,omitzero"`
	ActualLoops        value.Optional[float64] `json:"Actual Loops,omitzero"`
	Plans              []PlanNode              `json:"Plans,omitempty"`
}

type PlannedValue struct {
	Sql       string
	Arguments []any
	Shape     string
}

type PredicateState = predicateState

type ProjectionColumn struct {
	Sensitive bool
	Name      string
	Typ       reflect.Type
	Nullable  bool
}

type ProjectionMapping struct {
	Sensitive  bool
	Column     ProjectionColumn
	Expression ValueExpression
}

type QueryCore struct {
	Table      string
	Predicates []Expression
	Orders     []QueryOrder
	Limit      value.Optional[int]
	Offset     int

	SoftDeleteScope SoftDeleteScope
	// Global scope options: removed scopes, all scopes removed, and the
	// context that resolves context scopes (see WithScopeContext).
	WithoutScopes []GlobalScopeName
	AllScopesOff  bool
	ScopeContext  context.Context
	// skipModelHooks acknowledges hook-free set-based writes only.
	SkipModelHooks bool
	// distinctOnKey is set only by one-of-many relation loading.
	DistinctOnKey *FieldRef
	Model         *ModelDefinition
}

type QueryOrder struct {
	Field      FieldRef
	Computed   *ComputedOrder
	Descending bool
	Nulls      NullPlacement
}

type RangeDistance struct {
	Parameter ParameterNode
	Interval  *temporal.Interval
	Err       error
}

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

type ReadKind uint8

type RecordLayout struct {
	Node       SelectNode
	Columns    []Column
	HasDecoder bool
	Err        error
}

type RecursiveCTE struct {
	Reference *RecursiveReference
	Step      SelectNode
	Operator  SetOperator
}

type RecursiveReference struct {
	Name    string
	Columns []Column
}

type RelationLimits struct{ BatchSize, MaxRows, MaxDepth int }

type RelationOrder struct {
	Value             ValueExpression
	Descending, Pivot bool
	Nulls             NullPlacement
}

type ResultCursorField struct {
	Name             string
	Sensitive, Valid bool
}

type RowComparison struct {
	Operands []ValueExpression
	Operator Operator
	Values   *RowValuesState
}

type RowValuesState = rowValuesState

type ScalarOperation uint8

type ScalarSubquery struct{ Query Subquery }

type ScopeDefinition struct {
	Name      GlobalScopeName
	Predicate Expression
	Resolve   func(context.Context) (Expression, error)
}

type ScopeNode struct {
	Name    GlobalScopeName
	Context context.Context
	// needsContext marks a context scope; a deferred scope expansion resolves
	// its own context scopes and may run without a context.
	NeedsContext bool
	Resolve      func(context.Context) (Expression, error)
}

type ScopeRequirement struct {
	Sources map[string][]Column
	Err     error
}

type Sealer func(context.Context, *encryption.Keyring, encryption.Context) (AssignmentValue, error)

type SelectItem struct {
	Sensitive  bool // Explicit result-codec sensitivity, independent of its SQL expression.
	Expression ValueExpression
	Alias      string
}

type SelectKeys struct {
	Index      ValueIndex
	Entries    []*CompiledKey
	Fields     map[FieldRef]*CompiledKey
	Kinds      map[reflect.Type]bool
	GroupCount int
}

type SelectNames struct{ Used map[string]bool }

type SelectNode struct {
	Locks      []LockSpec
	Source     TableSource
	Selections []SelectItem // Empty selects the constant 1, used by count/exists.
	Distinct   DistinctSpec
	GroupBy    []ValueExpression
	Joins      []JoinNode
	Predicates []Expression
	Having     []Expression
	Orders     []OrderNode
	Limit      value.Optional[int]
	Offset     int
}

type SelectWalk struct {
	Parameter            func(ParameterNode)
	Sensitive            func()
	SubqueryVisitor      func(Subquery, int)
	Named                func(*NamedWindow, int)
	Window               func(WindowNode)
	LocalSelect          bool
	Source               func(TableSource, int)
	Field                func(FieldRef)
	Correlation          func(ScopeRequirement)
	Nodes                int
	Err                  error
	RecursiveRestriction string
}

type SensitiveValue struct{ Value ValueExpression }

type SetNode struct {
	Left, Right SelectNode
	Operator    SetOperator
}

type SetOperator uint8

type SimplePage[R any] struct {
	Items        []R
	Number, Size int
	HasMore      bool
}

type SoftDeleteColumn struct{ Name string }

type SoftDeleteScope uint8

type SourceWriteKey struct {
	Expression ValueExpression
	Nullable   bool
}

type Statement struct {
	SQLText  string
	Bindings []any
	Shape    string
}

type StatementState = statementState

type Subquery struct {
	// RelationCheck defers declaration checks until compilation, preserving lazy
	// enum initialization while retaining a static AST for nested alias planning.
	RelationCheck func() error
	Node          SelectNode
	Err           error
	Correlation   *ScopeRequirement
}

type SubqueryPredicate struct {
	Query   Subquery
	Operand ValueExpression // nil means EXISTS; otherwise single-column IN.
}

type TableSource struct {
	// RequiresTransaction follows the source through alias and join lowering,
	// including unlocked sources whose public adapters require a transaction.
	RequiresTransaction bool
	Sensitive           map[string]bool // Immutable base-column sensitivity, retained by direct aliases.
	Table, Alias        string
	Columns             []Column
	Query               *SelectNode
	Cte                 *CteNode
	Set                 *SetNode
	Self                *RecursiveReference
}

type TemporalUnit uint8

type TimestampColumns struct{ Created, Updated string }

type ValueExpression interface{ ValueNode() }

type ValueIndex struct {
	Values                 []PlannedValue
	Slots                  map[string][]int
	Comparisons, Arguments int
}

type WindowFrame struct {
	Kind       FrameKind
	Start, End FrameBound
	Exclusion  FrameExclusion
	RangeType  codec.ParameterType
}

type WindowFunction uint8

type WindowNode struct {
	Kind        WindowFunction
	Window      WindowSpec
	Input       ValueExpression
	Aggregate   AggregateNode
	N           *OffsetState
	Fallback    *LiteralState
	HasFallback bool
	Err         error
}

type WindowSpec struct {
	Reference  *NamedWindow
	Partitions []ValueExpression
	Orders     []OrderNode
	Frame      *WindowFrame
	Err        error
}