530 lines
13 KiB
Go
530 lines
13 KiB
Go
// Copyright 2016 PingCAP, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package core
|
|
|
|
import (
|
|
"github.com/pingcap/tidb/expression"
|
|
"github.com/pingcap/tidb/util/disjointset"
|
|
)
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalProjection) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, expr := range p.Exprs {
|
|
p.Exprs[i], err = expr.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
childProj, isProj := p.children[0].(*PhysicalProjection)
|
|
if !isProj {
|
|
return
|
|
}
|
|
refine4NeighbourProj(p, childProj)
|
|
return
|
|
}
|
|
|
|
// refine4NeighbourProj refines the index for p.Exprs whose type is *Column when
|
|
// there is two neighbouring Projections.
|
|
// This function is introduced because that different childProj.Expr may refer
|
|
// to the same index of childProj.Schema, so we need to keep this relation
|
|
// between the specified expressions in the parent Projection.
|
|
func refine4NeighbourProj(p, childProj *PhysicalProjection) {
|
|
inputIdx2OutputIdxes := make(map[int][]int)
|
|
for i, expr := range childProj.Exprs {
|
|
col, isCol := expr.(*expression.Column)
|
|
if !isCol {
|
|
continue
|
|
}
|
|
inputIdx2OutputIdxes[col.Index] = append(inputIdx2OutputIdxes[col.Index], i)
|
|
}
|
|
childSchemaUnionSet := disjointset.NewIntSet(childProj.schema.Len())
|
|
for _, outputIdxes := range inputIdx2OutputIdxes {
|
|
if len(outputIdxes) <= 1 {
|
|
continue
|
|
}
|
|
for i := 1; i < len(outputIdxes); i++ {
|
|
childSchemaUnionSet.Union(outputIdxes[0], outputIdxes[i])
|
|
}
|
|
}
|
|
|
|
for _, expr := range p.Exprs {
|
|
col, isCol := expr.(*expression.Column)
|
|
if !isCol {
|
|
continue
|
|
}
|
|
col.Index = childSchemaUnionSet.FindRoot(col.Index)
|
|
}
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalHashJoin) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
lSchema := p.children[0].Schema()
|
|
rSchema := p.children[1].Schema()
|
|
for i, fun := range p.EqualConditions {
|
|
lArg, err := fun.GetArgs()[0].ResolveIndices(lSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
rArg, err := fun.GetArgs()[1].ResolveIndices(rSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.EqualConditions[i] = expression.NewFunctionInternal(fun.GetCtx(), fun.FuncName.L, fun.GetType(), lArg, rArg).(*expression.ScalarFunction)
|
|
}
|
|
for i, expr := range p.LeftConditions {
|
|
p.LeftConditions[i], err = expr.ResolveIndices(lSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.RightConditions {
|
|
p.RightConditions[i], err = expr.ResolveIndices(rSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.OtherConditions {
|
|
p.OtherConditions[i], err = expr.ResolveIndices(expression.MergeSchema(lSchema, rSchema))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalMergeJoin) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
lSchema := p.children[0].Schema()
|
|
rSchema := p.children[1].Schema()
|
|
for i, col := range p.LeftKeys {
|
|
newKey, err := col.ResolveIndices(lSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.LeftKeys[i] = newKey.(*expression.Column)
|
|
}
|
|
for i, col := range p.RightKeys {
|
|
newKey, err := col.ResolveIndices(rSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.RightKeys[i] = newKey.(*expression.Column)
|
|
}
|
|
for i, expr := range p.LeftConditions {
|
|
p.LeftConditions[i], err = expr.ResolveIndices(lSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.RightConditions {
|
|
p.RightConditions[i], err = expr.ResolveIndices(rSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.OtherConditions {
|
|
p.OtherConditions[i], err = expr.ResolveIndices(expression.MergeSchema(lSchema, rSchema))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalIndexJoin) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
lSchema := p.children[0].Schema()
|
|
rSchema := p.children[1].Schema()
|
|
for i := range p.InnerJoinKeys {
|
|
newOuterKey, err := p.OuterJoinKeys[i].ResolveIndices(p.children[p.OuterIndex].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.OuterJoinKeys[i] = newOuterKey.(*expression.Column)
|
|
newInnerKey, err := p.InnerJoinKeys[i].ResolveIndices(p.children[1-p.OuterIndex].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.InnerJoinKeys[i] = newInnerKey.(*expression.Column)
|
|
}
|
|
for i, expr := range p.LeftConditions {
|
|
p.LeftConditions[i], err = expr.ResolveIndices(lSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.RightConditions {
|
|
p.RightConditions[i], err = expr.ResolveIndices(rSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
mergedSchema := expression.MergeSchema(lSchema, rSchema)
|
|
for i, expr := range p.OtherConditions {
|
|
p.OtherConditions[i], err = expr.ResolveIndices(mergedSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalUnionScan) ResolveIndices() (err error) {
|
|
err = p.basePhysicalPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, expr := range p.Conditions {
|
|
p.Conditions[i], err = expr.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalTableReader) ResolveIndices() error {
|
|
return p.tablePlan.ResolveIndices()
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalIndexReader) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = p.indexPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, col := range p.OutputColumns {
|
|
newCol, err := col.ResolveIndices(p.indexPlan.Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.OutputColumns[i] = newCol.(*expression.Column)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalIndexLookUpReader) ResolveIndices() (err error) {
|
|
err = p.tablePlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = p.indexPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalSelection) ResolveIndices() (err error) {
|
|
err = p.basePhysicalPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, expr := range p.Conditions {
|
|
p.Conditions[i], err = expr.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *basePhysicalAgg) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, aggFun := range p.AggFuncs {
|
|
for i, arg := range aggFun.Args {
|
|
aggFun.Args[i], err = arg.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
for i, item := range p.GroupByItems {
|
|
p.GroupByItems[i], err = item.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalSort) ResolveIndices() (err error) {
|
|
err = p.basePhysicalPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, item := range p.ByItems {
|
|
item.Expr, err = item.Expr.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalWindow) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i := 0; i < len(p.Schema().Columns)-1; i++ {
|
|
col := p.Schema().Columns[i]
|
|
newCol, err := col.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.Schema().Columns[i] = newCol.(*expression.Column)
|
|
}
|
|
for i, item := range p.PartitionBy {
|
|
newCol, err := item.Col.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.PartitionBy[i].Col = newCol.(*expression.Column)
|
|
}
|
|
for i, item := range p.OrderBy {
|
|
newCol, err := item.Col.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.OrderBy[i].Col = newCol.(*expression.Column)
|
|
}
|
|
for i, arg := range p.WindowFuncDesc.Args {
|
|
p.WindowFuncDesc.Args[i], err = arg.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
if p.Frame != nil {
|
|
for i := range p.Frame.Start.CalcFuncs {
|
|
p.Frame.Start.CalcFuncs[i], err = p.Frame.Start.CalcFuncs[i].ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i := range p.Frame.End.CalcFuncs {
|
|
p.Frame.End.CalcFuncs[i], err = p.Frame.End.CalcFuncs[i].ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalTopN) ResolveIndices() (err error) {
|
|
err = p.basePhysicalPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, item := range p.ByItems {
|
|
item.Expr, err = item.Expr.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *PhysicalApply) ResolveIndices() (err error) {
|
|
err = p.physicalSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = p.PhysicalJoin.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for i, col := range p.schema.Columns {
|
|
newCol, err := col.ResolveIndices(p.PhysicalJoin.schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.schema.Columns[i] = newCol.(*expression.Column)
|
|
}
|
|
for _, col := range p.OuterSchema {
|
|
newCol, err := col.Column.ResolveIndices(p.children[0].Schema())
|
|
if err != nil {
|
|
return err
|
|
}
|
|
col.Column = *newCol.(*expression.Column)
|
|
}
|
|
joinedSchema := expression.MergeSchema(p.children[0].Schema(), p.children[1].Schema())
|
|
for i, cond := range p.PhysicalJoin.EqualConditions {
|
|
newSf, err := cond.ResolveIndices(joinedSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.PhysicalJoin.EqualConditions[i] = newSf.(*expression.ScalarFunction)
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *Update) ResolveIndices() (err error) {
|
|
err = p.baseSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
schema := p.SelectPlan.Schema()
|
|
for _, assign := range p.OrderedList {
|
|
newCol, err := assign.Col.ResolveIndices(schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
assign.Col = newCol.(*expression.Column)
|
|
assign.Expr, err = assign.Expr.ResolveIndices(schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *Insert) ResolveIndices() (err error) {
|
|
err = p.baseSchemaProducer.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, asgn := range p.OnDuplicate {
|
|
newCol, err := asgn.Col.ResolveIndices(p.tableSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
asgn.Col = newCol.(*expression.Column)
|
|
asgn.Expr, err = asgn.Expr.ResolveIndices(p.Schema4OnDuplicate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, set := range p.SetList {
|
|
newCol, err := set.Col.ResolveIndices(p.tableSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
set.Col = newCol.(*expression.Column)
|
|
set.Expr, err = set.Expr.ResolveIndices(p.tableSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for i, expr := range p.GenCols.Exprs {
|
|
p.GenCols.Exprs[i], err = expr.ResolveIndices(p.tableSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
for _, asgn := range p.GenCols.OnDuplicates {
|
|
newCol, err := asgn.Col.ResolveIndices(p.tableSchema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
asgn.Col = newCol.(*expression.Column)
|
|
asgn.Expr, err = asgn.Expr.ResolveIndices(p.Schema4OnDuplicate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *Show) ResolveIndices() (err error) {
|
|
for i, expr := range p.Conditions {
|
|
p.Conditions[i], err = expr.ResolveIndices(p.schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return err
|
|
}
|
|
|
|
func (p *physicalSchemaProducer) ResolveIndices() (err error) {
|
|
err = p.basePhysicalPlan.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if p.schema != nil {
|
|
for i, cols := range p.schema.TblID2Handle {
|
|
for j, col := range cols {
|
|
resolvedCol, err := col.ResolveIndices(p.schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.schema.TblID2Handle[i][j] = resolvedCol.(*expression.Column)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (p *baseSchemaProducer) ResolveIndices() (err error) {
|
|
if p.schema != nil {
|
|
for i, cols := range p.schema.TblID2Handle {
|
|
for j, col := range cols {
|
|
resolvedCol, err := col.ResolveIndices(p.schema)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
p.schema.TblID2Handle[i][j] = resolvedCol.(*expression.Column)
|
|
}
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ResolveIndices implements Plan interface.
|
|
func (p *basePhysicalPlan) ResolveIndices() (err error) {
|
|
for _, child := range p.children {
|
|
err = child.ResolveIndices()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
return
|
|
}
|