query

type BuriedExistentialPredicateError ¶

type BuriedExistentialPredicateError struct{}

BuriedExistentialPredicateError signals that a translated plan tree carries a WHERE existential predicate (an ExistentialValuePredicate) buried under a wrapper that is NOT a directly-handled semi-join shape — i.e. it is neither a top-level existential nor a single-NOT-wrapped existential. Such a predicate falls into the regular-predicate bucket of the NLJ rule's implementExistentialSelect / implementJoinWithExistential, where the empty FirstOrDefault inner emits its NULL default that no residual filter removes, so EVERY outer row silently passes (a silent wrong result). The production path rejects such a plan with ErrCodeUnsupportedQuery rather than ship wrong rows (RFC-141 R4 convergence backstop, P1a).

The cleanly-rejected shapes are the wrapped-WHERE-EXISTS long tail: any existential reachable only through a wrapper the rule's IsExistentialPredicate / IsNotExistentialPredicate routing does not recognise — `WHERE NOT (NOT EXISTS(...))`, `WHERE EXISTS(...) OR p`, deeper AND/OR/NOT nesting. A plain `WHERE EXISTS` / `WHERE NOT EXISTS` (top-level or single-NOT-wrapped) is the directly-handled shape and is NOT rejected.

func (e *BuriedExistentialPredicateError) Error() string

type Generator ¶

type Generator interface {
	// Plan parses, semantically analyzes, and plans a SQL string.
	// Errors are typed via pkg/relational/api — callers should not
	// need to wrap them.
	Plan(ctx context.Context, sql string) (Plan, error)
}

Generator builds executable Plans from SQL strings. One Generator per logical session — it carries the session's catalog handle, current schema, and options.

type MultiPlan ¶

type MultiPlan struct {
	Plans []Plan
}

MultiPlan wraps a sequence of Plans produced from a multi-statement SQL text (semicolon-separated). Execute runs them in order and returns a Result holding the SUM of RowsAffected (for Exec-style callers); the last Plan's Rows if any are exposed via Results(). This matches today's EmbeddedConnection.ExecContext aggregation: total modified rows across the batch, no intermediate result sets bubbled up.

func (m *MultiPlan) Execute(ctx context.Context) (Result, error)

func (m *MultiPlan) Explain() string

func (m *MultiPlan) IsUpdate() bool

type Plan ¶

type Plan interface {
	Execute(ctx context.Context) (Result, error)
	IsUpdate() bool
	Explain() string
}

Plan is a ready-to-execute representation of a SQL statement. One Plan per SQL statement; a multi-statement SQL text produces a MultiPlan (see below).

Execute returns a Result whose concrete shape depends on the statement kind:

• SELECT / SHOW / read-only: Result.Rows is non-nil; Result. RowsAffected is zero.
• INSERT / UPDATE / DELETE: Result.RowsAffected counts the modified rows; Result.Rows is nil.
• DDL (CREATE / DROP): Result.Rows is nil; Result.RowsAffected is zero.

IsUpdate distinguishes mutation plans so the driver knows whether to return driver.Rows vs driver.Result at the boundary. Matches Java's Plan.isUpdatePlan().

Explain returns a textual description of the plan. Today the naive Generator returns the canonical SQL text; future Cascades plans will return a plan tree that is stable enough for the RFC-022 §4.-1 plan-equivalence harness to diff against Java's. Empty string is a valid value for plans that cannot produce a useful description.

type PlanFunc ¶

type PlanFunc struct {
	ExecFn    func(ctx context.Context) (Result, error)
	UpdateFn  func() bool
	ExplainFn func() string
}

PlanFunc is a convenience adapter: a Plan whose Execute delegates to a closure. Used to wrap non-Cascades code paths (e.g. the executor-free INFORMATION_SCHEMA system-table handler and the explain-only renderer) as Plan implementations without duplicating logic.

Post-Phase-1c this adapter becomes obsolete — physical operator types implement Plan directly. Kept here during the transition so the frontend seam is stable before the executor is split.

func (p *PlanFunc) Execute(ctx context.Context) (Result, error)

func (p *PlanFunc) Explain() string

func (p *PlanFunc) IsUpdate() bool

type Result ¶

type Result struct {
	// Rows is non-nil for SELECT-shaped plans. Nil for DML/DDL.
	Rows driver.Rows
	// RowsAffected is the update count for DML. Zero for SELECT/DDL.
	RowsAffected int64
}

Result is the output of a Plan execution. Exactly one of Rows / RowsAffected carries the payload; which one is set is determined by Plan.IsUpdate().

type ScalarSubqueryPlan ¶

type ScalarSubqueryPlan struct {
	Alias values.CorrelationIdentifier
	Plan  logical.LogicalOperator
}

ScalarSubqueryPlan pairs a correlation alias with a logical operator tree for a scalar subquery. Collected during translation and passed to the executor for pre-evaluation.

func TranslateToCascadesWithError(op logical.LogicalOperator, md *recordlayer.RecordMetaData) (*expressions.Reference, []ScalarSubqueryPlan, error)

func TranslateToCascadesWithSubqueries(op logical.LogicalOperator, md *recordlayer.RecordMetaData) (*expressions.Reference, []ScalarSubqueryPlan)

type UnfoldedProjectedExistsError ¶

type UnfoldedProjectedExistsError struct {
	// Alias is the existential correlation the offending ExistsValue reads.
	Alias values.CorrelationIdentifier
}

UnfoldedProjectedExistsError signals that a translated plan tree carries a projected ExistsValue that is NOT folded into the result value of the SelectExpression owning its existential quantifier — i.e. the boolean would be evaluated ABOVE the FlatMap, without the existential binding live, and ExistsValue.Evaluate would silently return false (or, via a QOV fallback, phantom-true). That is a silent wrong result, so the production path rejects such a plan with ErrCodeUnsupportedQuery rather than shipping wrong rows (RFC-141 §8 safety guard).

The cleanly-rejected shapes are the projected-EXISTS long tail the fold does not yet recognize (e.g. multiple existential quantifiers in one query, or a projection over a shape findExistsFilterUnderUnaryChain cannot fold through). They are correctness-preserving rejections, never wrong answers.

func (e *UnfoldedProjectedExistsError) Error() string