plancontext

type BindVarExpr struct {
	Name string
	Expr *sqlparser.ColName
}

type ContextCTE struct {
	*semantics.CTE
	Id         semantics.TableSet
	Predicates []*RecurseExpression
}

type PlannerVersion = querypb.ExecuteOptions_PlannerVersion

type PlanningContext struct {
	ReservedVars *sqlparser.ReservedVars
	SemTable     *semantics.SemTable
	VSchema      VSchema

	PlannerVersion querypb.ExecuteOptions_PlannerVersion

	// If we during planning have turned this expression into an argument name,
	// we can continue using the same argument name
	ReservedArguments map[sqlparser.Expr]string

	// VerifyAllFKs tells whether we need verification for all the fk constraints on VTGate.
	// This is required for queries we are running with /*+ SET_VAR(foreign_key_checks=OFF) */
	VerifyAllFKs bool

	// Projected subqueries that have been merged
	MergedSubqueries []*sqlparser.Subquery

	// CurrentPhase keeps track of how far we've gone in the planning process
	// The type should be operators.Phase, but depending on that would lead to circular dependencies
	CurrentPhase int

	// Statement contains the originally parsed statement
	Statement sqlparser.Statement

	// OuterTables contains the tables that are outer to the current query
	// Used to set the nullable flag on the columns
	OuterTables semantics.TableSet

	// This is a stack of CTEs being built. It's used when we have CTEs inside CTEs,
	// to remember which is the CTE currently being assembled
	CurrentCTE []*ContextCTE

	PredTracker *predicates.Tracker

	Conditions []engine.Condition
	// contains filtered or unexported fields
}

type RecurseExpression struct {
	JoinPredicateID *predicates.ID
	Original        sqlparser.Expr
	RightExpr       sqlparser.Expr
	LeftExprs       []BindVarExpr
}

type VSchema interface {
	FindTable(tablename sqlparser.TableName) (*vindexes.BaseTable, string, topodatapb.TabletType, key.ShardDestination, error)
	FindView(name sqlparser.TableName) sqlparser.TableStatement
	// FindViewTarget finds the target keyspace for the view table provided.
	FindViewTarget(name sqlparser.TableName) (*vindexes.Keyspace, error)
	FindTableOrVindex(tablename sqlparser.TableName) (*vindexes.BaseTable, vindexes.Vindex, string, topodatapb.TabletType, key.ShardDestination, error)

	// SelectedKeyspace returns the current keyspace if set, otherwise returns an error
	SelectedKeyspace() (*vindexes.Keyspace, error)
	TargetString() string
	ShardDestination() key.ShardDestination
	TabletType() topodatapb.TabletType
	TargetDestination(qualifier string) (key.ShardDestination, *vindexes.Keyspace, topodatapb.TabletType, error)
	AnyKeyspace() (*vindexes.Keyspace, error)
	FirstSortedKeyspace() (*vindexes.Keyspace, error)
	SysVarSetEnabled() bool
	KeyspaceExists(keyspace string) bool
	AllKeyspace() ([]*vindexes.Keyspace, error)
	FindKeyspace(keyspace string) (*vindexes.Keyspace, error)
	GetSemTable() *semantics.SemTable
	Planner() PlannerVersion
	SetPlannerVersion(pv PlannerVersion)
	ConnCollation() collations.ID
	Environment() *vtenv.Environment

	// ErrorIfShardedF will return an error if the keyspace is sharded,
	// and produce a warning if the vtgate if configured to do so
	ErrorIfShardedF(keyspace *vindexes.Keyspace, warn, errFmt string, params ...any) error

	// WarnUnshardedOnly is used when a feature is only supported in unsharded mode.
	// This will let the user know that they are using something
	// that could become a problem if they move to a sharded keyspace
	WarnUnshardedOnly(format string, params ...any)

	// PlannerWarning records warning created during planning.
	PlannerWarning(message string)

	// ForeignKeyMode returns the foreign_key flag value
	ForeignKeyMode(keyspace string) (vschemapb.Keyspace_ForeignKeyMode, error)

	// KeyspaceError returns any error in the keyspace vschema.
	KeyspaceError(keyspace string) error

	GetForeignKeyChecksState() *bool

	// GetVSchema returns the latest cached vindexes.VSchema
	GetVSchema() *vindexes.VSchema

	// GetSrvVschema returns the latest cached vschema.SrvVSchema
	GetSrvVschema() *vschemapb.SrvVSchema

	// FindRoutedShard looks up shard routing rules for a shard
	FindRoutedShard(keyspace, shard string) (string, error)

	// IsShardRoutingEnabled returns true if partial shard routing is enabled
	IsShardRoutingEnabled() bool

	// IsViewsEnabled returns true if Vitess manages the views.
	IsViewsEnabled() bool

	// GetUDV returns user defined value from the variable passed.
	GetUDV(name string) *querypb.BindVariable

	// PlanPrepareStatement plans the prepared statement.
	PlanPrepareStatement(ctx context.Context, query string) (*engine.Plan, error)

	// ClearPrepareData clears the prepared data from the session.
	ClearPrepareData(stmtName string)

	// GetPrepareData returns the prepared data for the statement from the session.
	GetPrepareData(stmtName string) *vtgatepb.PrepareData

	// StorePrepareData stores the prepared data in the session.
	StorePrepareData(name string, v *vtgatepb.PrepareData)

	// GetAggregateUDFs returns the list of aggregate UDFs.
	GetAggregateUDFs() []string

	// FindMirrorRule finds the mirror rule for the requested keyspace, table
	// name, and the tablet type in the VSchema.
	FindMirrorRule(tablename sqlparser.TableName) (*vindexes.MirrorRule, error)

	// GetBindVars returns the bindvars. If we are executing a prepared statement for the first time,
	// we re-plan with the bindvar values to see if we find any better plans now that we can see parameter values.
	// If we find a better plan, we store it, and use it when the bindvars line up
	GetBindVars() map[string]*querypb.BindVariable
}