core

type AdminPlugins struct {
	physicalop.SimpleSchemaProducer
	Action  AdminPluginsAction
	Plugins []string
}

type AdminPluginsAction int

type AdminShowBDRRole struct {
	physicalop.SimpleSchemaProducer
}

type AggregateFuncExtractor struct {

	// AggFuncs is the collected AggregateFuncExprs.
	AggFuncs []*ast.AggregateFuncExpr
	// contains filtered or unexported fields
}

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

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

type AlterDDLJob struct {
	physicalop.SimpleSchemaProducer

	JobID   int64
	Options []*AlterDDLJobOpt
}

type AlterDDLJobOpt struct {
	Name  string
	Value expression.Expression
}

type Analyze struct {
	physicalop.SimpleSchemaProducer

	ColTasks []AnalyzeColumnsTask
	IdxTasks []AnalyzeIndexTask
	Opts     map[ast.AnalyzeOptionType]uint64
	// OptionsMap is used to store the options for each partition.
	OptionsMap map[int64]V2AnalyzeOptions
}

type AnalyzeColumnsTask struct {
	HandleCols       util.HandleCols
	CommonHandleInfo *model.IndexInfo
	ColsInfo         []*model.ColumnInfo
	SkipColsInfo     []*model.ColumnInfo
	TblInfo          *model.TableInfo
	Indexes          []*model.IndexInfo
	AnalyzeInfo
}

type AnalyzeIndexTask struct {
	IndexInfo *model.IndexInfo
	TblInfo   *model.TableInfo
	AnalyzeInfo
}

type AnalyzeInfo struct {
	DBName        string
	TableName     string
	PartitionName string
	TableID       statistics.AnalyzeTableID
	StatsVersion  int
	V2Options     *V2AnalyzeOptions
}

type CancelDDLJobs struct {
	physicalop.SimpleSchemaProducer

	JobIDs []int64
}

type CheckIndexRange struct {
	physicalop.SimpleSchemaProducer

	Table     *ast.TableName
	IndexName string

	HandleRanges []ast.HandleRange
}

type CheckTable struct {
	physicalop.SimpleSchemaProducer

	DBName             string
	Table              table.Table
	IndexInfos         []*model.IndexInfo
	IndexLookUpReaders []*physicalop.PhysicalIndexLookUpReader
	CheckIndex         bool
}

type ChecksumTable struct {
	physicalop.SimpleSchemaProducer

	Tables []*resolve.TableNameW
}

type CleanupIndex struct {
	physicalop.SimpleSchemaProducer

	Table     *resolve.TableNameW
	IndexName string
}

type ClusterLogTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool

	// NodeTypes represents all components types we should send request to.
	// e.g:
	// 1. SELECT * FROM cluster_log WHERE type='tikv'
	// 2. SELECT * FROM cluster_log WHERE type in ('tikv', 'tidb')
	NodeTypes set.StringSet

	// Instances represents all components instances we should send request to.
	// e.g:
	// 1. SELECT * FROM cluster_log WHERE instance='192.168.1.7:2379'
	// 2. SELECT * FROM cluster_log WHERE instance in ('192.168.1.7:2379', '192.168.1.9:2379')
	Instances set.StringSet

	// StartTime represents the beginning time of log message
	// e.g: SELECT * FROM cluster_log WHERE time>'2019-10-10 10:10:10.999'
	StartTime int64
	// EndTime represents the ending time of log message
	// e.g: SELECT * FROM cluster_log WHERE time<'2019-10-11 10:10:10.999'
	EndTime int64
	// Pattern is used to filter the log message
	// e.g:
	// 1. SELECT * FROM cluster_log WHERE message like '%gc%'
	// 2. SELECT * FROM cluster_log WHERE message regexp '.*'
	Patterns  []string
	LogLevels set.StringSet
	// contains filtered or unexported fields
}

type ClusterTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool

	// NodeTypes represents all components types we should send request to.
	// e.g:
	// 1. SELECT * FROM cluster_config WHERE type='tikv'
	// 2. SELECT * FROM cluster_config WHERE type in ('tikv', 'tidb')
	NodeTypes set.StringSet

	// Instances represents all components instances we should send request to.
	// e.g:
	// 1. SELECT * FROM cluster_config WHERE instance='192.168.1.7:2379'
	// 2. SELECT * FROM cluster_config WHERE type in ('192.168.1.7:2379', '192.168.1.9:2379')
	Instances set.StringSet
	// contains filtered or unexported fields
}

type CompactTable struct {
	physicalop.SimpleSchemaProducer

	ReplicaKind    ast.CompactReplicaKind
	TableInfo      *model.TableInfo
	PartitionNames []ast.CIStr
}

type ConvertOuterToInnerJoin struct {
}

type DDL struct {
	physicalop.SimpleSchemaProducer

	Statement ast.DDLNode
}

type Deallocate struct {
	physicalop.SimpleSchemaProducer

	Name string
}

type DecorrelateSolver struct{}

type DeriveTopNFromWindow struct {
}

type DistributeTable struct {
	physicalop.SimpleSchemaProducer
	TableInfo      *model.TableInfo
	PartitionNames []ast.CIStr
	Engine         string
	Rule           string
	Timeout        string
}

type EliminateUnionAllDualItem struct {
}

type EmptySelectionEliminator struct{}

type ErrExprLoc struct {
	Offset int
	Loc    string
}

type Execute struct {
	physicalop.SimpleSchemaProducer

	Name     string
	Params   []expression.Expression
	PrepStmt *PlanCacheStmt
	Stmt     ast.StmtNode
	Plan     base.Plan
}

type Explain struct {
	physicalop.SimpleSchemaProducer

	TargetPlan       base.Plan
	Format           string
	Analyze          bool
	Explore          bool   // EXPLAIN EXPLORE statement
	SQLDigest        string // "EXPLAIN EXPLORE <sql_digest>"
	ExecStmt         ast.StmtNode
	RuntimeStatsColl *execdetails.RuntimeStatsColl

	Rows            [][]string
	BriefBinaryPlan string
}

type ExplainInfoForEncode struct {
	ID                  string                  `json:"id"`
	EstRows             string                  `json:"estRows"`
	ActRows             string                  `json:"actRows,omitempty"`
	TaskType            string                  `json:"taskType"`
	AccessObject        string                  `json:"accessObject,omitempty"`
	ExecuteInfo         string                  `json:"executeInfo,omitempty"`
	OperatorInfo        string                  `json:"operatorInfo,omitempty"`
	EstCost             string                  `json:"estCost,omitempty"`
	CostFormula         string                  `json:"costFormula,omitempty"`
	MemoryInfo          string                  `json:"memoryInfo,omitempty"`
	DiskInfo            string                  `json:"diskInfo,omitempty"`
	TotalMemoryConsumed string                  `json:"totalMemoryConsumed,omitempty"`
	SubOperators        []*ExplainInfoForEncode `json:"subOperators,omitempty"`
}

type ExprColumnMap map[expression.Expression]*expression.Column

type FlatOperator struct {
	// A reference to the original operator.
	Origin base.Plan

	// ChildrenIdx is the indexes of the children of this operator in the FlatPlanTree.
	// It's ordered from small to large.
	ChildrenIdx []int
	// ChildrenEndIdx is the index of the last operator of children subtrees of this operator in the FlatPlanTree.
	ChildrenEndIdx int

	// NeedReverseDriverSide means if we need to reverse the order of children to keep build side before probe side.
	//
	// Specifically, it means if the below are all true:
	// 1. this operator has two children
	// 2. the first child's Label is the probe side and the second's is the build side.
	//
	// If you call FlattenPhysicalPlan with buildSideFirst true, NeedReverseDriverSide will be useless.
	NeedReverseDriverSide bool

	Depth     uint32
	Label     OperatorLabel
	IsRoot    bool
	StoreType kv.StoreType
	// ReqType is only meaningful when IsRoot is false.
	ReqType physicalop.ReadReqType

	// The below two fields are mainly for text tree formatting. See texttree.PrettyIdentifier().
	TextTreeIndent string
	IsLastChild    bool

	// IsINLProbeChild will change the underlying tableScan to rowIDScan for example.
	// IsINLProbeChild indicates whether this operator is in indexLookupReader or indexMergeReader inner side.
	IsINLProbeChild bool

	IsPhysicalPlan bool
}

type FlatPhysicalPlan struct {
	Main             FlatPlanTree
	CTEs             []FlatPlanTree
	ScalarSubQueries []FlatPlanTree

	// InExecute means if the original plan tree contains Execute operator.
	//
	// Be careful when trying to use this, InExecute is true doesn't mean we are handling an EXECUTE statement.
	// When collecting information from the plan in an EXECUTE statement, usually we directly use the plan
	// in Execute.Plan, not Execute itself, so InExecute will be false.
	//
	// When will InExecute be true? When you're using "EXPLAIN FOR CONNECTION" to get the last plan of
	// a connection (usually we will record Explain.TargetPlan for an EXPLAIN statement) and that plan
	// is from an EXECUTE statement, we will collect from Execute itself, not directly from Execute.Plan,
	// then InExecute will be true.
	InExecute bool

	// InExplain means if the original plan tree contains Explain operator.
	InExplain bool
	// contains filtered or unexported fields
}

type FlatPlanTree []*FlatOperator

type GcSubstituter struct {
}

type HotRegionsHistoryTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any pd server.
	SkipRequest bool

	// StartTime represents the beginning time of update time.
	// e.g: SELECT * FROM tidb_hot_regions_history WHERE update_time>'2019-10-10 10:10:10.999'
	StartTime int64
	// EndTime represents the ending time of update time.
	// e.g: SELECT * FROM tidb_hot_regions_history WHERE update_time<'2019-10-11 10:10:10.999'
	EndTime int64

	// RegionIDs/StoreIDs/PeerIDs represents all region/store/peer ids we should filter in PD to reduce network IO.
	// e.g:
	// 1. SELECT * FROM tidb_hot_regions_history WHERE region_id=1
	// 2. SELECT * FROM tidb_hot_regions_history WHERE table_id in (11, 22)
	// Leave range operation to above selection executor.
	RegionIDs []uint64
	StoreIDs  []uint64
	PeerIDs   []uint64
	// IsLearners/IsLeaders represents whether we should request for learner/leader role in PD to reduce network IO.
	// e.g:
	// 1. SELECT * FROM tidb_hot_regions_history WHERE is_learner=1
	// 2. SELECT * FROM tidb_hot_regions_history WHERE is_learner in (0,1) -> request all
	IsLearners []bool
	IsLeaders  []bool

	// HotRegionTypes represents all hot region types we should filter in PD to reduce network IO.
	// e.g:
	// 1. SELECT * FROM tidb_hot_regions_history WHERE type='read'
	// 2. SELECT * FROM tidb_hot_regions_history WHERE type in ('read', 'write')
	// 3. SELECT * FROM tidb_hot_regions_history WHERE type='read' and type='write' -> SkipRequest = true
	HotRegionTypes set.StringSet
	// contains filtered or unexported fields
}

type ImportInto struct {
	physicalop.SimpleSchemaProducer

	Table              *resolve.TableNameW
	ColumnAssignments  []*ast.Assignment
	ColumnsAndUserVars []*ast.ColumnNameOrUserVar
	Path               string
	Format             *string
	Options            []*LoadDataOpt

	GenCols physicalop.InsertGeneratedColumns
	Stmt    string

	SelectPlan base.PhysicalPlan
}

type IndexUsageIndexInfo struct {
	Name string
	ID   int64
}

type InfoSchemaBaseExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool
	// ColPredicates records the columns that can be extracted from the predicates.
	// For example, `select * from information_schema.SCHEMATA where schema_name='mysql' or schema_name='INFORMATION_SCHEMA'`
	// {"schema_name": ["mysql", "INFORMATION_SCHEMA"]}
	ColPredicates map[string]set.StringSet

	// used for EXPLAIN only
	LikePatterns map[string][]string
	// contains filtered or unexported fields
}

type InfoSchemaCheckConstraintsExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaColumnsExtractor struct {
	InfoSchemaBaseExtractor
	// contains filtered or unexported fields
}

type InfoSchemaDDLExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaIndexesExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaKeyColumnUsageExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaPartitionsExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaReferConstExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaSchemataExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaSequenceExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaStatisticsExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaTableConstraintsExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaTablesExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaTiDBCheckConstraintsExtractor struct {
	InfoSchemaBaseExtractor
}

type InfoSchemaTiDBIndexUsageExtractor struct {
	InfoSchemaBaseExtractor
	// contains filtered or unexported fields
}

type InfoSchemaViewsExtractor struct {
	InfoSchemaBaseExtractor
}

type InspectionResultTableExtractor struct {

	// SkipInspection means the where clause always false, we don't need to request any component
	SkipInspection bool
	// Rules represents rules applied to, and we should apply all inspection rules if there is no rules specified
	// e.g: SELECT * FROM inspection_result WHERE rule in ('ddl', 'config')
	Rules set.StringSet
	// Items represents items applied to, and we should apply all inspection item if there is no rules specified
	// e.g: SELECT * FROM inspection_result WHERE item in ('ddl.lease', 'raftstore.threadpool')
	Items set.StringSet
	// contains filtered or unexported fields
}

type InspectionRuleTableExtractor struct {
	SkipRequest bool
	Types       set.StringSet
	// contains filtered or unexported fields
}

type InspectionSummaryTableExtractor struct {

	// SkipInspection means the where clause always false, we don't need to request any component
	SkipInspection bool
	// Rules represents rules applied to, and we should apply all inspection rules if there is no rules specified
	// e.g: SELECT * FROM inspection_summary WHERE rule in ('ddl', 'config')
	Rules       set.StringSet
	MetricNames set.StringSet
	Quantiles   []float64
	// contains filtered or unexported fields
}

type JoinReOrderSolver struct {
}

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

type LineFieldsInfo struct {
	FieldsTerminatedBy string
	FieldsEnclosedBy   string // length always <= 1, see parser.y
	FieldsEscapedBy    string // length always <= 1, see parser.y
	FieldsOptEnclosed  bool
	LinesStartingBy    string
	LinesTerminatedBy  string
}

type LoadData struct {
	physicalop.SimpleSchemaProducer

	FileLocRef  ast.FileLocRefTp
	OnDuplicate ast.OnDuplicateKeyHandlingType
	Path        string
	Format      *string
	Table       *resolve.TableNameW
	Charset     *string
	Columns     []*ast.ColumnName
	FieldsInfo  *ast.FieldsClause
	LinesInfo   *ast.LinesClause
	IgnoreLines *uint64

	ColumnAssignments  []*ast.Assignment
	ColumnsAndUserVars []*ast.ColumnNameOrUserVar
	Options            []*LoadDataOpt

	GenCols physicalop.InsertGeneratedColumns
}

type LoadDataOpt struct {
	// Name is the name of the option, converted to lower case during parse.
	Name  string
	Value expression.Expression
}

type LoadStats struct {
	physicalop.SimpleSchemaProducer

	Path string
}

type LockStats struct {
	physicalop.SimpleSchemaProducer

	Tables []*ast.TableName
}

type MetricSummaryTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest  bool
	MetricsNames set.StringSet
	Quantiles    []float64
	// contains filtered or unexported fields
}

type MetricTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool
	// StartTime represents the beginning time of metric data.
	StartTime time.Time
	// EndTime represents the ending time of metric data.
	EndTime time.Time
	// LabelConditions represents the label conditions of metric data.
	LabelConditions map[string]set.StringSet
	Quantiles       []float64
	// contains filtered or unexported fields
}

type OperatorLabel uint8

type OuterJoinEliminator struct {
}

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

type PPDSolver struct{}

type PauseDDLJobs struct {
	physicalop.SimpleSchemaProducer

	JobIDs []int64
}

type PhysicalSimpleWrapper struct {
	physicalop.BasePhysicalPlan
	Inner Simple
}

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

type PlanBuilderOpt interface {
	Apply(builder *PlanBuilder)
}

type PlanBuilderOptAllowCastArray struct{}

type PlanBuilderOptNoExecution struct{}

type PlanCacheKeyEnableInstancePlanCache struct{}

type PlanCacheKeyTestClone struct{}

type PlanCacheKeyTestIssue43667 struct{}

type PlanCacheKeyTestIssue46760 struct{}

type PlanCacheKeyTestIssue47133 struct{}

type PlanCacheStmt struct {
	PreparedAst *ast.Prepared
	ResolveCtx  *resolve.Context
	StmtDB      string // which DB the statement will be processed over
	VisitInfos  []visitInfo
	Params      []ast.ParamMarkerExpr

	PointGet PointGetExecutorCache

	// below fields are for PointGet short path
	SchemaVersion int64

	// RelateVersion stores the true cache plan table schema version, since each table schema can be updated separately in transaction.
	RelateVersion map[int64]uint64

	StmtCacheable     bool   // Whether this stmt is cacheable.
	UncacheableReason string // Why this stmt is uncacheable.

	NormalizedSQL       string
	NormalizedPlan      string
	SQLDigest           *parser.Digest
	PlanDigest          *parser.Digest
	ForUpdateRead       bool
	SnapshotTSEvaluator func(context.Context, sessionctx.Context) (uint64, error)

	BindingInfo bindinfo.BindingMatchInfo

	// the different between NormalizedSQL, NormalizedSQL4PC and StmtText:
	//  for the query `select * from t where a>1 and b<?`, then
	//  NormalizedSQL: select * from `t` where `a` > ? and `b` < ? --> constants are normalized to '?',
	//  NormalizedSQL4PC: select * from `test` . `t` where `a` > ? and `b` < ? --> schema name is added,
	//  StmtText: select * from t where a>1 and b <? --> just format the original query;
	StmtText string
	// contains filtered or unexported fields
}

type PlanCacheValue struct {
	// Meta Info, all are READ-ONLY once initialized.
	SQLDigest        string
	SQLText          string
	StmtType         string             // select, update, insert, delete, etc.
	ParseUser        string             // the user who parses/compiles this plan.
	Binding          string             // the binding of this plan.
	OptimizerEnvHash string             // other environment information that might affect the plan like "time_zone", "sql_mode".
	ParseValues      string             // the actual values used when parsing/compiling this plan.
	PlanDigest       string             // digest of the plan, used to identify the plan in the cache.
	BinaryPlan       string             // binary of this Plan, use tidb_decode_binary_plan to decode this.
	Memory           int64              // the memory usage of this plan, in bytes.
	LoadTime         time.Time          // the time when this plan is loaded into the cache.
	Plan             base.Plan          // READ-ONLY for Instance Cache, READ-WRITE for Session Cache.
	OutputColumns    types.NameSlice    // output column names of this plan
	ParamTypes       []*types.FieldType // all parameters' types, different parameters may share same plan
	StmtHints        *hint.StmtHints    // related hints of this plan, like 'max_execution_time'.
	// contains filtered or unexported fields
}

type PlanReplayer struct {
	physicalop.SimpleSchemaProducer
	ExecStmt          ast.StmtNode
	Analyze           bool
	Load              bool
	File              string
	HistoricalStatsTS uint64

	Capture    bool
	Remove     bool
	SQLDigest  string
	PlanDigest string
}

type PointGetExecutorCache struct {
	ColumnInfos any
	// Executor is only used for point get scene.
	// Notice that we should only cache the PointGetExecutor that have a snapshot with MaxTS in it.
	// If the current plan is not PointGet or does not use MaxTS optimization, this value should be nil here.
	Executor any

	// FastPlan is only used for instance plan cache.
	// To ensure thread-safe, we have to clone each plan before reusing if using instance plan cache.
	// To reduce the memory allocation and increase performance, we cache the FastPlan here.
	FastPlan *physicalop.PointGetPlan
}

type PointPlanVal struct {
	Plan base.Plan
}

type Prepare struct {
	physicalop.SimpleSchemaProducer

	Name    string
	SQLText string
}

type PreprocessOpt func(*preprocessor)

type PreprocessorReturn struct {
	IsStaleness         bool
	SnapshotTSEvaluator func(context.Context, sessionctx.Context) (uint64, error)
	// LastSnapshotTS is the last evaluated snapshotTS if any
	// otherwise it defaults to zero
	LastSnapshotTS uint64
	InfoSchema     infoschema.InfoSchema
	// contains filtered or unexported fields
}

type ProjectionEliminator struct {
}

type PushDownSequenceSolver struct {
}

type PushDownTopNOptimizer struct {
}

type RecommendIndexPlan struct {
	physicalop.SimpleSchemaProducer

	Action   string
	SQL      string
	AdviseID int64
	Options  []ast.RecommendIndexOption
}

type RecoverIndex struct {
	physicalop.SimpleSchemaProducer

	Table     *resolve.TableNameW
	IndexName string
}

type ReloadExprPushdownBlacklist struct {
	physicalop.SimpleSchemaProducer
}

type ReloadOptRuleBlacklist struct {
	physicalop.SimpleSchemaProducer
}

type ResolveExpand struct {
}

type ResultReorder struct {
}

type ResumeDDLJobs struct {
	physicalop.SimpleSchemaProducer

	JobIDs []int64
}

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

type SQLBindOpDetail struct {
	NormdOrigSQL string
	BindSQL      string
	BindStmt     ast.StmtNode
	Db           string
	Charset      string
	Collation    string
	NewStatus    string
	Source       string // Source indicate how this binding was created, eg: bindinfo.Manual or bindinfo.History
	SQLDigest    string
	PlanDigest   string
}

type SQLBindOpType int

type SQLBindPlan struct {
	physicalop.SimpleSchemaProducer

	IsGlobal  bool
	SQLBindOp SQLBindOpType
	Details   []*SQLBindOpDetail
}

type ScalarSubQueryExpr struct {
	expression.Constant
	// contains filtered or unexported fields
}

type ScalarSubqueryEvalCtx struct {
	baseimpl.Plan
	// contains filtered or unexported fields
}

type SelectInto struct {
	physicalop.SimpleSchemaProducer

	TargetPlan base.Plan
	IntoOpt    *ast.SelectIntoOption
	LineFieldsInfo
}

type SemiJoinRewriter struct {
}

type Set struct {
	physicalop.SimpleSchemaProducer

	VarAssigns []*expression.VarAssignment
}

type SetConfig struct {
	physicalop.SimpleSchemaProducer

	Type     string
	Instance string
	Name     string
	Value    expression.Expression
}

type ShowBaseExtractor struct {
	ast.ShowStmt
	// contains filtered or unexported fields
}

type ShowDDL struct {
	physicalop.SimpleSchemaProducer
}

type ShowDDLJobQueries struct {
	physicalop.SimpleSchemaProducer

	JobIDs []int64
}

type ShowDDLJobQueriesWithRange struct {
	physicalop.SimpleSchemaProducer

	Limit  uint64
	Offset uint64
}

type ShowNextRowID struct {
	physicalop.SimpleSchemaProducer
	TableName *ast.TableName
}

type ShowSlow struct {
	physicalop.SimpleSchemaProducer

	*ast.ShowSlow
}

type Simple struct {
	physicalop.SimpleSchemaProducer

	Statement ast.StmtNode

	// IsFromRemote indicates whether the statement IS FROM REMOTE TiDB instance in cluster,
	//   and executing in co-processor.
	//   Used for `global kill`. See https://github.com/pingcap/tidb/blob/master/docs/design/2020-06-01-global-kill.md.
	IsFromRemote bool

	// StaleTxnStartTS is the StartTS that is used to build a staleness transaction by 'START TRANSACTION READ ONLY' statement.
	StaleTxnStartTS uint64

	ResolveCtx *resolve.Context
}

type SkewDistinctAggRewriter struct {
}

type SlowQueryExtractor struct {
	SkipRequest bool
	TimeRanges  []*TimeRange
	// Enable is true means the executor should use the time range to locate the slow-log file that need to be parsed.
	// Enable is false, means the executor should keep the behavior compatible with before, which is only parse the
	// current slow-log file.
	Enable bool
	Desc   bool
	// contains filtered or unexported fields
}

type SplitRegion struct {
	physicalop.SimpleSchemaProducer

	TableInfo      *model.TableInfo
	PartitionNames []ast.CIStr
	IndexInfo      *model.IndexInfo
	Lower          []types.Datum
	Upper          []types.Datum
	Num            int
	ValueLists     [][]types.Datum
}

type SplitRegionStatus struct {
	physicalop.SimpleSchemaProducer

	Table     table.Table
	IndexInfo *model.IndexInfo
}

type StatementsSummaryExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool
	// Digests represents digest applied to, and we should apply all digest if there is no digest specified.
	// e.g: SELECT * FROM STATEMENTS_SUMMARY WHERE digest='8019af26debae8aa7642c501dbc43212417b3fb14e6aec779f709976b7e521be'
	Digests set.StringSet

	// Coarse time range predicate extracted from the where clause as:
	// SELECT ... WHERE summary_begin_time <= endTime AND summary_end_time >= startTime
	//
	// N.B. it's only used by v2, so we should keep predicates not changed when extracting time range, or it will
	// affect the correctness with v1.
	CoarseTimeRange *TimeRange
	// contains filtered or unexported fields
}

type TableStorageStatsExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component.
	SkipRequest bool
	// TableSchema represents tableSchema applied to, and we should apply all table disk usage if there is no schema specified.
	// e.g: SELECT * FROM information_schema.disk_usage WHERE table_schema in ('test', 'information_schema').
	TableSchema set.StringSet
	// TableName represents tableName applied to, and we should apply all table disk usage if there is no table specified.
	// e.g: SELECT * FROM information_schema.disk_usage WHERE table in ('schemata', 'tables').
	TableName set.StringSet
	// contains filtered or unexported fields
}

type TiFlashSystemTableExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool
	// TiFlashInstances represents all tiflash instances we should send request to.
	// e.g:
	// 1. SELECT * FROM information_schema.<table_name> WHERE tiflash_instance='192.168.1.7:3930'
	// 2. SELECT * FROM information_schema.<table_name> WHERE tiflash_instance in ('192.168.1.7:3930', '192.168.1.9:3930')
	TiFlashInstances set.StringSet
	// TidbDatabases represents tidbDatabases applied to, and we should apply all tidb database if there is no database specified.
	// e.g: SELECT * FROM information_schema.<table_name> WHERE tidb_database in ('test', 'test2').
	TiDBDatabases string
	// TidbTables represents tidbTables applied to, and we should apply all tidb table if there is no table specified.
	// e.g: SELECT * FROM information_schema.<table_name> WHERE tidb_table in ('t', 't2').
	TiDBTables string
	// contains filtered or unexported fields
}

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

type TikvRegionPeersExtractor struct {

	// SkipRequest means the where clause always false, we don't need to request any component
	SkipRequest bool

	// RegionIDs/StoreIDs represents all region/store ids we should filter in PD to reduce network IO.
	// e.g:
	// 1. SELECT * FROM tikv_region_peers WHERE region_id=1
	// 2. SELECT * FROM tikv_region_peers WHERE table_id in (11, 22)
	RegionIDs []uint64
	StoreIDs  []uint64
	// contains filtered or unexported fields
}

type TimeRange struct {
	StartTime time.Time
	EndTime   time.Time
}

type Trace struct {
	physicalop.SimpleSchemaProducer

	StmtNode   ast.StmtNode
	ResolveCtx *resolve.Context
	Format     string

	// OptimizerTrace indicates `trace plan target = 'xxx' <statement>` case
	OptimizerTrace       bool
	OptimizerTraceTarget string
}

type Traffic struct {
	physicalop.SimpleSchemaProducer
	OpType  ast.TrafficOpType
	Options []*ast.TrafficOption
	Dir     string
}

type UnlockStats struct {
	physicalop.SimpleSchemaProducer

	Tables []*ast.TableName
}

type V2AnalyzeOptions struct {
	PhyTableID  int64
	RawOpts     map[ast.AnalyzeOptionType]uint64
	FilledOpts  map[ast.AnalyzeOptionType]uint64
	ColChoice   ast.ColumnChoice
	ColumnList  []*model.ColumnInfo
	IsPartition bool
}

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

type WorkloadRepoCreate struct {
	physicalop.SimpleSchemaProducer
}