func (b *executorBuilder) columnToPBExpr(client kv.Client, column *expression.Column, tbl *model.TableInfo) *tipb.Expr {
if !client.SupportRequestType(kv.ReqTypeSelect, int64(tipb.ExprType_ColumnRef)) {
return nil
}
switch column.GetType().Tp {
case mysql.TypeBit, mysql.TypeSet, mysql.TypeEnum, mysql.TypeDecimal, mysql.TypeGeometry,
mysql.TypeDate, mysql.TypeNewDate, mysql.TypeDatetime, mysql.TypeTimestamp, mysql.TypeYear:
return nil
}
id := int64(-1)
for _, col := range tbl.Columns {
if tbl.Name == column.TblName && col.Name == column.ColName {
id = col.ID
break
}
}
// Zero Column ID is not a column from table, can not support for now.
if id == 0 {
return nil
}
// TODO：If the column ID isn't in fields, it means the column is from an outer table,
// its value is available to use.
if id == -1 {
return nil
}
return &tipb.Expr{
Tp: tipb.ExprType_ColumnRef.Enum(),
Val: codec.EncodeInt(nil, id)}
}
func findColumnIndexByGroup(groups []LogicalPlan, col *expression.Column) int {
for i, plan := range groups {
idx := plan.GetSchema().GetIndex(col)
if idx != -1 {
return i
}
}
log.Errorf("Unknown columns %s, from id %s, position %d", col.ToString(), col.FromID, col.Position)
return -1
}
func (e *havingAndOrderbyResolver) addProjectionExpr(v *ast.ColumnNameExpr, projCol *expression.Column) {
// Avoid to append same column repeatly.
for i, expr := range e.proj.Exprs {
if expr == projCol {
e.mapper[v] = e.proj.schema[i]
return
}
}
e.proj.Exprs = append(e.proj.Exprs, projCol)
schemaCols, _ := projCol.DeepCopy().(*expression.Column)
e.mapper[v] = schemaCols
e.proj.schema = append(e.proj.schema, schemaCols)
}
func (pc pbConverter) columnToPBExpr(column *expression.Column) *tipb.Expr {
if !pc.client.SupportRequestType(kv.ReqTypeSelect, int64(tipb.ExprType_ColumnRef)) {
return nil
}
switch column.GetType().Tp {
case mysql.TypeBit, mysql.TypeSet, mysql.TypeEnum, mysql.TypeGeometry, mysql.TypeDecimal:
return nil
}
id := column.ID
// Zero Column ID is not a column from table, can not support for now.
if id == 0 || id == -1 {
return nil
}
return &tipb.Expr{
Tp: tipb.ExprType_ColumnRef,
Val: codec.EncodeInt(nil, id)}
}
func shallowCopyColumn(colDest, colSrc *expression.Column) *expression.Column {
colDest.Correlated = colSrc.Correlated
colDest.FromID = colSrc.FromID
colDest.Position = colSrc.Position
colDest.ID = colSrc.ID
colDest.IsAggOrSubq = colSrc.IsAggOrSubq
colDest.RetType = colSrc.RetType
return colDest
}
// propagateConstant propagate constant values of equality predicates and inequality predicates in a condition.
func propagateConstant(conditions []expression.Expression) []expression.Expression {
if len(conditions) == 0 {
return conditions
}
// Propagate constants in equality predicates.
// e.g. for condition: "a = b and b = c and c = a and a = 1";
// we propagate constant as the following step:
// first: "1 = b and b = c and c = 1 and a = 1";
// next: "1 = b and 1 = c and c = 1 and a = 1";
// next: "1 = b and 1 = c and 1 = 1 and a = 1";
// next: "1 = b and 1 = c and a = 1";
// e.g for condition: "a = b and b = c and b = 2 and a = 1";
// we propagate constant as the following step:
// first: "a = 2 and 2 = c and b = 2 and a = 1";
// next: "a = 2 and 2 = c and b = 2 and 2 = 1";
// next: "0"
isSource := make([]bool, len(conditions))
type transitiveEqualityPredicate map[string]*expression.Constant // transitive equality predicates between one column and one constant
for {
equalities := make(transitiveEqualityPredicate, 0)
for i, getOneEquality := 0, false; i < len(conditions) && !getOneEquality; i++ {
if isSource[i] {
continue
}
expr, ok := conditions[i].(*expression.ScalarFunction)
if !ok {
continue
}
// process the included OR conditions recursively to do the same for CNF item.
switch expr.FuncName.L {
case ast.OrOr:
expressions := expression.SplitDNFItems(conditions[i])
newExpression := make([]expression.Expression, 0)
for _, v := range expressions {
newExpression = append(newExpression, propagateConstant([]expression.Expression{v})...)
}
conditions[i] = expression.ComposeDNFCondition(newExpression)
isSource[i] = true
case ast.AndAnd:
newExpression := propagateConstant(expression.SplitCNFItems(conditions[i]))
conditions[i] = expression.ComposeCNFCondition(newExpression)
isSource[i] = true
case ast.EQ:
var (
col *expression.Column
val *expression.Constant
)
leftConst, leftIsConst := expr.Args[0].(*expression.Constant)
rightConst, rightIsConst := expr.Args[1].(*expression.Constant)
leftCol, leftIsCol := expr.Args[0].(*expression.Column)
rightCol, rightIsCol := expr.Args[1].(*expression.Column)
if rightIsConst && leftIsCol {
col = leftCol
val = rightConst
} else if leftIsConst && rightIsCol {
col = rightCol
val = leftConst
} else {
continue
}
equalities[string(col.HashCode())] = val
isSource[i] = true
getOneEquality = true
}
}
if len(equalities) == 0 {
break
}
for i := 0; i < len(conditions); i++ {
if isSource[i] {
continue
}
if len(equalities) != 0 {
conditions[i] = constantSubstitute(equalities, conditions[i])
}
}
}
// Propagate transitive inequality predicates.
// e.g for conditions "a = b and c = d and a = c and g = h and b > 0 and e != 0 and g like 'abc'",
// we propagate constant as the following step:
// 1. build multiple equality predicates(mep):
// =(a, b, c, d), =(g, h).
// 2. extract inequality predicates between one constant and one column,
// and rewrite them using the root column of a multiple equality predicate:
// b > 0, e != 0, g like 'abc' ==> a > 0, g like 'abc'.
// ATTENTION: here column 'e' doesn't belong to any mep, so we skip "e != 0".
// 3. propagate constants in these inequality predicates, and we finally get:
// "a = b and c = d and a = c and e = f and g = h and e != 0 and a > 0 and b > 0 and c > 0 and d > 0 and g like 'abc' and h like 'abc' ".
multipleEqualities := make(map[*expression.Column]*expression.Column, 0)
for _, cond := range conditions { // build multiple equality predicates.
expr, ok := cond.(*expression.ScalarFunction)
if ok && expr.FuncName.L == ast.EQ {
left, ok1 := expr.Args[0].(*expression.Column)
right, ok2 := expr.Args[1].(*expression.Column)
if ok1 && ok2 {
UnionColumns(left, right, multipleEqualities)
}
}
}
if len(multipleEqualities) == 0 {
return conditions
}
inequalityFuncs := map[string]string{
ast.LT: ast.LT,
ast.GT: ast.GT,
ast.LE: ast.LE,
ast.GE: ast.GE,
ast.NE: ast.NE,
ast.Like: ast.Like,
}
type inequalityFactor struct {
FuncName string
Factor []*expression.Constant
}
type transitiveInEqualityPredicate map[string][]inequalityFactor // transitive inequality predicates between one column and one constant.
inequalities := make(transitiveInEqualityPredicate, 0)
for i := 0; i < len(conditions); i++ { // extract inequality predicates.
var (
column *expression.Column
equalCol *expression.Column // the root column corresponding to a column in a multiple equality predicate.
val *expression.Constant
funcName string
)
expr, ok := conditions[i].(*expression.ScalarFunction)
if !ok {
continue
}
funcName, ok = inequalityFuncs[expr.FuncName.L]
if !ok {
continue
}
leftConst, leftIsConst := expr.Args[0].(*expression.Constant)
rightConst, rightIsConst := expr.Args[1].(*expression.Constant)
leftCol, leftIsCol := expr.Args[0].(*expression.Column)
rightCol, rightIsCol := expr.Args[1].(*expression.Column)
if rightIsConst && leftIsCol {
column = leftCol
val = rightConst
} else if leftIsConst && rightIsCol {
column = rightCol
val = leftConst
} else {
continue
}
equalCol, ok = multipleEqualities[column]
if !ok { // no need to propagate inequality predicates whose column is only equal to itself.
continue
}
colHashCode := string(equalCol.HashCode())
if funcName == ast.Like { // func 'LIKE' need 3 input arguments, so here we handle it alone.
inequalities[colHashCode] = append(inequalities[colHashCode], inequalityFactor{FuncName: ast.Like, Factor: []*expression.Constant{val, expr.Args[2].(*expression.Constant)}})
} else {
inequalities[colHashCode] = append(inequalities[colHashCode], inequalityFactor{FuncName: funcName, Factor: []*expression.Constant{val}})
}
conditions = append(conditions[:i], conditions[i+1:]...)
i--
}
if len(inequalities) == 0 {
return conditions
}
for k, v := range multipleEqualities { // propagate constants in inequality predicates.
for _, x := range inequalities[string(v.HashCode())] {
funcName, factors := x.FuncName, x.Factor
if funcName == ast.Like {
for i := 0; i < len(factors); i += 2 {
newFunc, _ := expression.NewFunction(funcName, types.NewFieldType(mysql.TypeTiny), k, factors[i], factors[i+1])
conditions = append(conditions, newFunc)
}
} else {
for i := 0; i < len(factors); i++ {
newFunc, _ := expression.NewFunction(funcName, types.NewFieldType(mysql.TypeTiny), k, factors[i])
conditions = append(conditions, newFunc)
i++
}
}
}
}
return conditions
}
func (e *havingAndOrderbyResolver) addProjectionExpr(v *ast.ColumnNameExpr, projCol *expression.Column) {
e.proj.Exprs = append(e.proj.Exprs, projCol)
schemaCols, _ := projCol.DeepCopy().(*expression.Column)
e.mapper[v] = schemaCols
e.proj.schema = append(e.proj.schema, schemaCols)
}