executor

var (
	// ErrNotConcurrentIndexBuild is returned when the statement is not a
	// single CREATE INDEX ... CONCURRENTLY.
	ErrNotConcurrentIndexBuild = errors.New("statement is not a CREATE INDEX CONCURRENTLY")
	// ErrUnnamedIndex is returned when the concurrent build does not name
	// its index: without a deterministic identity there is no idempotent
	// way to find and recover the invalid leftover of a failed build.
	ErrUnnamedIndex = errors.New("concurrent index build must name its index")
	// ErrUnqualifiedTable is returned when the target table is not
	// schema-qualified. The post-failure catalog verdict re-resolves the
	// table on another session, where search_path cannot be proven
	// identical to the build session's — an unqualified name could resolve
	// to a different table and turn the verdict into a false clean.
	ErrUnqualifiedTable = errors.New("concurrent index build must schema-qualify its table")
	// ErrIfNotExistsUnsupported is returned for CREATE INDEX CONCURRENTLY
	// IF NOT EXISTS. The clause checks only the name: it succeeds as a
	// no-op while an invalid or unrelated index owns that name, so the
	// executor could report success over an index it cannot vouch for.
	ErrIfNotExistsUnsupported = errors.New("CREATE INDEX CONCURRENTLY IF NOT EXISTS is not supported: a name-only no-op cannot prove the existing index is valid or even the requested one")
	// ErrPreexistingInvalidIndex is returned when an invalid index with the
	// requested name already exists in the target schema — on any table.
	// The executor cannot prove who owns that entry — an in-progress
	// concurrent build by another actor is invalid until it finishes — and
	// after a failure of its own it could never distinguish that entry
	// from its own leftover, so it refuses to build. This state is not a
	// drop instruction: the index may be healthy and mid-build (see
	// docs/invalid-index-recovery.md).
	ErrPreexistingInvalidIndex = errors.New("an invalid index with this name already exists in the target schema")
	// ErrBuildLeftInvalidIndex is returned (inside an *InvalidIndexError)
	// when this executor's own build left an invalid catalog entry behind:
	// after a failure, once the build's backend provably stopped, or after
	// a reported success whose validity verification found the entry
	// invalid. The executor never removes it automatically: PostgreSQL
	// drops by name, not identity, so an automatic drop could destroy
	// another actor's index registered under the same name in the same
	// window. The recovery is the operator's explicit DROP INDEX
	// CONCURRENTLY (see docs/invalid-index-recovery.md).
	ErrBuildLeftInvalidIndex = errors.New("the build left an invalid index behind")
	// ErrTargetIdentityChanged is returned (inside an *InvalidIndexError)
	// when the target table no longer resolves to the OID the build was
	// admitted against: it was dropped, replaced, or renamed while the
	// build ran. The catalog can no longer prove whether the failed build
	// left debris — the verdict is indeterminate, and indeterminate fails
	// closed.
	ErrTargetIdentityChanged = errors.New("the target table was dropped or replaced during the build: the catalog cannot prove whether the failed build left an invalid index")
	// ErrTableNotFound is returned when the statement's qualified table
	// resolves to nothing before the build starts; it distinguishes a
	// missing table from an inspection failure so callers can branch with
	// errors.Is instead of matching message text.
	ErrTableNotFound = errors.New("table not found")
	// ErrPoolTooSmall is returned at admission when the pool cannot hold
	// the build session and the verdict session at once. The verdict is a
	// correctness dependency, not a nicety: without a reserved second
	// connection, every failed build would resolve indeterminate. Like an
	// unbounded budget, an unusable verdict is refused by construction.
	ErrPoolTooSmall = errors.New("concurrent index build needs a pool of at least two connections: one for the build session, one reserved for the catalog verdict")
	// ErrCancelledExternally is returned when the build's statement was
	// cancelled (SQLSTATE 57014) before its overall budget elapsed: the
	// executor's statement_timeout cannot have fired yet, so the
	// cancellation came from outside — an operator's pg_cancel_backend, an
	// administrative tool. It is deliberately not a *BudgetError: a budget
	// exhaustion invites escalation to a heavier strategy, while a
	// deliberate cancel usually means the change should be left alone.
	ErrCancelledExternally = errors.New("the build was cancelled from outside the executor before its budget elapsed")
)

var (
	// ErrEmptySequence is returned for a sequence with no steps: reporting
	// success over nothing executed would be a false proof.
	ErrEmptySequence = errors.New("sequence has no steps")
	// ErrUnsupportedSequenceStep is returned when a step is not one of the
	// shapes this executor can run safely: an ALTER TABLE step, or a
	// CREATE INDEX CONCURRENTLY step. The concurrent forms of other
	// statements are refused deliberately — a DROP INDEX CONCURRENTLY or
	// REINDEX CONCURRENTLY is not driven yet, and a cancelled
	// DETACH PARTITION CONCURRENTLY leaves a detach-pending partition
	// state this executor does not own detecting or recovering.
	ErrUnsupportedSequenceStep = errors.New("step is not a shape the sequence executor can run safely")
	// ErrUnsupportedPartitionedParent is returned when the target is a
	// partitioned parent and the admitted sequence is not supported there.
	ErrUnsupportedPartitionedParent = errors.New("sequence is not supported on a partitioned parent")
)

var ErrInvariantViolation = errors.New("invariant violation")