check

const (
	ScopeNone        ScopeFlag = 0
	ScopePreRun      ScopeFlag = 1 << 0
	ScopePreflight   ScopeFlag = 1 << 1
	ScopePostSetup   ScopeFlag = 1 << 2
	ScopeCutover     ScopeFlag = 1 << 3
	ScopePostCutover ScopeFlag = 1 << 4
	ScopeTesting     ScopeFlag = 1 << 5
	// ScopeStatement marks checks a caller can run ahead of an apply to learn
	// that Spirit will refuse a statement. Most are preflight checks that also
	// run as part of a migration; a check registered only here predicts, from
	// the statement, a refusal a later scope makes for every statement it
	// refuses. Callers run them via
	// RunChecks with Resources.Statement set and, optionally,
	// Resources.Table — the table's current metadata, which widens coverage to
	// the checks that compare the statement against the existing column
	// definitions. Neither needs a database connection: Table can be built
	// from the table's DDL with statement.CreateTable.ToTableInfo. A check
	// tagged with this scope must tolerate every Resources field except
	// Statement being unset.
	//
	// A failure here is a refusal the caller can report as certain, so the
	// scope only carries checks that no earlier stage can bypass on any
	// server. The migration runner runs this scope itself, once it has loaded
	// the tables and before it attempts MySQL's native DDL, so it refuses
	// every statement these checks refuse. Spirit attempts that native DDL —
	// ALGORITHM=INSTANT, then a safe-INPLACE subset — before it runs
	// preflight checks, and MySQL decides what that completes, which varies
	// with the server version and the table. A preflight check the native DDL
	// may complete (dropadd, rename) is deliberately excluded: claiming those
	// as refusals would report failure for an apply that succeeds, and the
	// runner, running them here, would then make it fail.
	//
	// That exclusion only ever under-reports, which is the safe direction:
	// passing these checks is not a promise Spirit will accept the statement,
	// only a failure is a claim. An excluded check still refuses at preflight
	// whenever the native attempt does not take the statement — Spirit skips
	// the attempt altogether for a multi-table change, and an older server
	// rejects shapes a newer one completes instantly. Checks that need a live
	// connection (existing foreign keys, triggers, privileges, ...) are not in
	// this scope either: they run at preflight, and the foreign key and
	// trigger checks run again before and during the cutover, to catch one
	// created while the migration runs.
	//
	// A caller that reports these refusals somewhere other than its own logs
	// judges the text by reading the checks that produce it, and a check added
	// to the scope is picked up without any change on the caller's side. Pin
	// the membership with ChecksInScope to keep that judgement attached to the
	// checks it was made about.
	ScopeStatement ScopeFlag = 1 << 6
	// ScopeCutoverLocked runs while the cutover holds its table lock, after
	// the final flush and immediately before the RENAME. LOCK TABLES ... WRITE
	// keeps out any DDL that needs a metadata lock on the table, so a check
	// here sees the state the RENAME acts on. The runner stops acting on
	// schema-change notifications once the cutover starts, so this is the
	// only check of anything created while the cutover waits for its lock.
	// A refusal (an error that matches ErrRefused, see refuse) fails the
	// cutover without a retry. Any other error is retried like any other
	// cutover failure, so a check must return ErrRefused for a permanent
	// condition, or it takes the table lock again on every retry. Keep these
	// checks to fast reads: they run while the application's writes to the
	// table are blocked.
	ScopeCutoverLocked ScopeFlag = 1 << 7
)