func (b *executorBuilder) buildNewTableScan(v *plan.PhysicalTableScan, s *plan.Selection) Executor {
txn, err := b.ctx.GetTxn(false)
if err != nil {
b.err = errors.Trace(err)
return nil
}
table, _ := b.is.TableByID(v.Table.ID)
client := txn.GetClient()
var memDB bool
switch v.DBName.L {
case "information_schema", "performance_schema":
memDB = true
}
supportDesc := client.SupportRequestType(kv.ReqTypeSelect, kv.ReqSubTypeDesc)
if !memDB && client.SupportRequestType(kv.ReqTypeSelect, 0) {
var ret Executor
st := &NewXSelectTableExec{
tableInfo: v.Table,
ctx: b.ctx,
txn: txn,
supportDesc: supportDesc,
asName: v.TableAsName,
table: table,
schema: v.GetSchema(),
Columns: v.Columns,
ranges: v.Ranges,
desc: v.Desc,
limitCount: v.LimitCount,
keepOrder: v.KeepOrder,
}
ret = st
if !txn.IsReadOnly() {
if s != nil {
ret = b.buildNewUnionScanExec(ret,
expression.ComposeCNFCondition(append(s.Conditions, v.AccessCondition...)))
} else {
ret = b.buildNewUnionScanExec(ret, expression.ComposeCNFCondition(v.AccessCondition))
}
}
if s != nil {
st.where, s.Conditions = b.toPBExpr(s.Conditions, st.tableInfo)
}
return ret
}
ts := &NewTableScanExec{
t: table,
asName: v.TableAsName,
ctx: b.ctx,
columns: v.Columns,
schema: v.GetSchema(),
seekHandle: math.MinInt64,
ranges: v.Ranges,
}
if v.Desc {
return &ReverseExec{Src: ts}
}
return ts
}
func (b *executorBuilder) buildTableScan(v *plan.PhysicalTableScan) Executor {
startTS := b.getStartTS()
if b.err != nil {
return nil
}
table, _ := b.is.TableByID(v.Table.ID)
client := b.ctx.GetClient()
var memDB bool
switch v.DBName.L {
case "information_schema", "performance_schema":
memDB = true
}
supportDesc := client.SupportRequestType(kv.ReqTypeSelect, kv.ReqSubTypeDesc)
if !memDB && client.SupportRequestType(kv.ReqTypeSelect, 0) {
st := &XSelectTableExec{
tableInfo: v.Table,
ctx: b.ctx,
startTS: startTS,
supportDesc: supportDesc,
asName: v.TableAsName,
table: table,
schema: v.GetSchema(),
Columns: v.Columns,
ranges: v.Ranges,
desc: v.Desc,
limitCount: v.LimitCount,
keepOrder: v.KeepOrder,
where: v.ConditionPBExpr,
aggregate: v.Aggregated,
aggFuncs: v.AggFuncs,
aggFields: v.AggFields,
byItems: v.GbyItems,
orderByList: v.SortItems,
}
return st
}
ts := &TableScanExec{
t: table,
asName: v.TableAsName,
ctx: b.ctx,
columns: v.Columns,
schema: v.GetSchema(),
seekHandle: math.MinInt64,
ranges: v.Ranges,
}
if v.Desc {
return &ReverseExec{Src: ts}
}
return ts
}
func (b *executorBuilder) buildTableScan(v *plan.PhysicalTableScan) Executor {
startTS := b.getStartTS()
if b.err != nil {
return nil
}
table, _ := b.is.TableByID(v.Table.ID)
client := b.ctx.GetClient()
memDB := infoschema.IsMemoryDB(v.DBName.L)
supportDesc := client.SupportRequestType(kv.ReqTypeSelect, kv.ReqSubTypeDesc)
if !memDB && client.SupportRequestType(kv.ReqTypeSelect, 0) {
st := &XSelectTableExec{
tableInfo: v.Table,
ctx: b.ctx,
startTS: startTS,
supportDesc: supportDesc,
asName: v.TableAsName,
table: table,
schema: v.GetSchema(),
Columns: v.Columns,
ranges: v.Ranges,
desc: v.Desc,
limitCount: v.LimitCount,
keepOrder: v.KeepOrder,
where: v.TableConditionPBExpr,
aggregate: v.Aggregated,
aggFuncs: v.AggFuncsPB,
aggFields: v.AggFields,
byItems: v.GbyItemsPB,
orderByList: v.SortItemsPB,
}
st.scanConcurrency, b.err = getScanConcurrency(b.ctx)
return st
}
ts := &TableScanExec{
t: table,
asName: v.TableAsName,
ctx: b.ctx,
columns: v.Columns,
schema: v.GetSchema(),
seekHandle: math.MinInt64,
ranges: v.Ranges,
isInfoSchema: strings.EqualFold(v.DBName.L, infoschema.Name),
}
if v.Desc {
return &ReverseExec{Src: ts}
}
return ts
}