// 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
}
