You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
202 lines
7.0 KiB
202 lines
7.0 KiB
// Copyright 2019 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 (
|
|
"context"
|
|
|
|
"github.com/pingcap/parser/ast"
|
|
"github.com/pingcap/parser/mysql"
|
|
"github.com/pingcap/tidb/expression"
|
|
"github.com/pingcap/tidb/sessionctx"
|
|
"github.com/pingcap/tidb/types"
|
|
)
|
|
|
|
type gcSubstituter struct {
|
|
}
|
|
|
|
// ExprColumnMap is used to store all expressions of indexed generated columns in a table,
|
|
// and map them to the generated columns,
|
|
// thus we can substitute the expression in a query to an indexed generated column.
|
|
type ExprColumnMap map[expression.Expression]*expression.Column
|
|
|
|
// optimize try to replace the expression to indexed virtual generate column in where, group by, order by, and field clause
|
|
// so that we can use the index on expression.
|
|
// For example: select a+1 from t order by a+1, with a virtual generate column c as (a+1) and
|
|
// an index on c. We need to replace a+1 with c so that we can use the index on c.
|
|
// See also https://dev.mysql.com/doc/refman/8.0/en/generated-column-index-optimizations.html
|
|
func (gc *gcSubstituter) optimize(ctx context.Context, lp LogicalPlan) (LogicalPlan, error) {
|
|
exprToColumn := make(ExprColumnMap)
|
|
collectGenerateColumn(lp, exprToColumn)
|
|
if len(exprToColumn) == 0 {
|
|
return lp, nil
|
|
}
|
|
return gc.substitute(ctx, lp, exprToColumn), nil
|
|
}
|
|
|
|
// Only integers can be substituted between different types now.
|
|
// Because they are all stored as 64-bit integers in chunks.
|
|
// And the inserted value will meet the requirements of virtual column type and virtual column expression type.
|
|
func getSubstitutableType(colType *types.FieldType) int {
|
|
switch colType.Tp {
|
|
case mysql.TypeTiny, mysql.TypeShort, mysql.TypeInt24, mysql.TypeLong, mysql.TypeLonglong:
|
|
return -1
|
|
}
|
|
return int(colType.Tp)
|
|
}
|
|
|
|
// We do not check whether flen is the same.
|
|
// Because different flen will not cause data truncation.
|
|
// See https://github.com/pingcap/tidb/pull/16316.
|
|
func checkSubstitutability(c1, c2 *types.FieldType) bool {
|
|
partialEqual := c1.Decimal == c2.Decimal &&
|
|
c1.Charset == c2.Charset &&
|
|
c1.Collate == c2.Collate &&
|
|
getSubstitutableType(c1) == getSubstitutableType(c2) &&
|
|
mysql.HasUnsignedFlag(c1.Flag) == mysql.HasUnsignedFlag(c2.Flag)
|
|
if !partialEqual || len(c1.Elems) != len(c2.Elems) {
|
|
return false
|
|
}
|
|
for i := range c1.Elems {
|
|
if c1.Elems[i] != c2.Elems[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// collectGenerateColumn collect the generate column and save them to a map from their expressions to themselves.
|
|
// For the sake of simplicity, we don't collect the stored generate column because we can't get their expressions directly.
|
|
// TODO: support stored generate column.
|
|
func collectGenerateColumn(lp LogicalPlan, exprToColumn ExprColumnMap) {
|
|
for _, child := range lp.Children() {
|
|
collectGenerateColumn(child, exprToColumn)
|
|
}
|
|
ds, ok := lp.(*DataSource)
|
|
if !ok {
|
|
return
|
|
}
|
|
tblInfo := ds.tableInfo
|
|
for _, idx := range tblInfo.Indices {
|
|
for _, idxPart := range idx.Columns {
|
|
colInfo := tblInfo.Columns[idxPart.Offset]
|
|
if colInfo.IsGenerated() && !colInfo.GeneratedStored {
|
|
s := ds.schema.Columns
|
|
col := expression.ColInfo2Col(s, colInfo)
|
|
if col != nil && checkSubstitutability(col.GetType(), col.VirtualExpr.GetType()) {
|
|
exprToColumn[col.VirtualExpr] = col
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func tryToSubstituteExpr(expr *expression.Expression, sctx sessionctx.Context, candidateExpr expression.Expression, tp types.EvalType, schema *expression.Schema, col *expression.Column) {
|
|
if (*expr).Equal(sctx, candidateExpr) && candidateExpr.GetType().EvalType() == tp &&
|
|
schema.ColumnIndex(col) != -1 {
|
|
*expr = col
|
|
}
|
|
}
|
|
|
|
func (gc *gcSubstituter) substitute(ctx context.Context, lp LogicalPlan, exprToColumn ExprColumnMap) LogicalPlan {
|
|
sctx := lp.SCtx().GetSessionVars().StmtCtx
|
|
var expr *expression.Expression
|
|
var tp types.EvalType
|
|
switch x := lp.(type) {
|
|
case *LogicalSelection:
|
|
for _, cond := range x.Conditions {
|
|
sf, ok := cond.(*expression.ScalarFunction)
|
|
if !ok {
|
|
continue
|
|
}
|
|
switch sf.FuncName.L {
|
|
case ast.EQ, ast.LT, ast.LE, ast.GT, ast.GE:
|
|
if sf.GetArgs()[0].ConstItem(sctx) {
|
|
expr = &sf.GetArgs()[1]
|
|
tp = sf.GetArgs()[0].GetType().EvalType()
|
|
} else if sf.GetArgs()[1].ConstItem(sctx) {
|
|
expr = &sf.GetArgs()[0]
|
|
tp = sf.GetArgs()[1].GetType().EvalType()
|
|
} else {
|
|
continue
|
|
}
|
|
for candidateExpr, column := range exprToColumn {
|
|
tryToSubstituteExpr(expr, lp.SCtx(), candidateExpr, tp, x.Schema(), column)
|
|
}
|
|
case ast.In:
|
|
expr = &sf.GetArgs()[0]
|
|
tp = sf.GetArgs()[1].GetType().EvalType()
|
|
canSubstitute := true
|
|
// Can only substitute if all the operands on the right-hand
|
|
// side are constants of the same type.
|
|
for i := 1; i < len(sf.GetArgs()); i++ {
|
|
if !sf.GetArgs()[i].ConstItem(sctx) || sf.GetArgs()[i].GetType().EvalType() != tp {
|
|
canSubstitute = false
|
|
break
|
|
}
|
|
}
|
|
if canSubstitute {
|
|
for candidateExpr, column := range exprToColumn {
|
|
tryToSubstituteExpr(expr, lp.SCtx(), candidateExpr, tp, x.Schema(), column)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
case *LogicalProjection:
|
|
for i := range x.Exprs {
|
|
tp = x.Exprs[i].GetType().EvalType()
|
|
for candidateExpr, column := range exprToColumn {
|
|
tryToSubstituteExpr(&x.Exprs[i], lp.SCtx(), candidateExpr, tp, x.children[0].Schema(), column)
|
|
}
|
|
}
|
|
case *LogicalSort:
|
|
for i := range x.ByItems {
|
|
tp = x.ByItems[i].Expr.GetType().EvalType()
|
|
for candidateExpr, column := range exprToColumn {
|
|
tryToSubstituteExpr(&x.ByItems[i].Expr, lp.SCtx(), candidateExpr, tp, x.Schema(), column)
|
|
}
|
|
}
|
|
// TODO: Uncomment these code after we support virtual generate column push down.
|
|
//case *LogicalAggregation:
|
|
// for _, aggFunc := range x.AggFuncs {
|
|
// for i := 0; i < len(aggFunc.Args); i++ {
|
|
// tp = aggFunc.Args[i].GetType().EvalType()
|
|
// for candidateExpr, column := range exprToColumn {
|
|
// if aggFunc.Args[i].Equal(lp.SCtx(), candidateExpr) && candidateExpr.GetType().EvalType() == tp &&
|
|
// x.Schema().ColumnIndex(column) != -1 {
|
|
// aggFunc.Args[i] = column
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// for i := 0; i < len(x.GroupByItems); i++ {
|
|
// tp = x.GroupByItems[i].GetType().EvalType()
|
|
// for candidateExpr, column := range exprToColumn {
|
|
// if x.GroupByItems[i].Equal(lp.SCtx(), candidateExpr) && candidateExpr.GetType().EvalType() == tp &&
|
|
// x.Schema().ColumnIndex(column) != -1 {
|
|
// x.GroupByItems[i] = column
|
|
// x.groupByCols = append(x.groupByCols, column)
|
|
// }
|
|
// }
|
|
// }
|
|
}
|
|
for _, child := range lp.Children() {
|
|
gc.substitute(ctx, child, exprToColumn)
|
|
}
|
|
return lp
|
|
}
|
|
|
|
func (*gcSubstituter) name() string {
|
|
return "generate_column_substitute"
|
|
}
|
|
|