func (e *Evaluator) patternRegexp(p *ast.PatternRegexpExpr) bool {
var sexpr string
if p.Sexpr != nil {
sexpr = *p.Sexpr
} else {
expr := p.Expr.GetDatum()
if expr.IsNull() {
p.SetNull()
return true
}
var err error
sexpr, err = expr.ToString()
if err != nil {
e.err = errors.Errorf("non-string Expression in LIKE: %v (Value of type %T)", expr, expr)
return false
}
if ast.IsConstant(p.Expr) {
p.Sexpr = new(string)
*p.Sexpr = sexpr
}
}
re := p.Re
if re == nil {
pattern := p.Pattern.GetDatum()
if pattern.IsNull() {
p.SetNull()
return true
}
spattern, err := pattern.ToString()
if err != nil {
e.err = errors.Errorf("non-string pattern in LIKE: %v (Value of type %T)", pattern, pattern)
return false
}
if re, err = regexp.Compile(spattern); err != nil {
e.err = errors.Trace(err)
return false
}
if ast.IsConstant(p.Pattern) {
p.Re = re
}
}
match := re.MatchString(sexpr)
if p.Not {
match = !match
}
p.SetInt64(boolToInt64(match))
return true
}
func (e *Evaluator) patternLike(p *ast.PatternLikeExpr) bool {
expr := p.Expr.GetDatum()
if expr.IsNull() {
p.SetNull()
return true
}
sexpr, err := expr.ToString()
if err != nil {
e.err = errors.Trace(err)
return false
}
// We need to compile pattern if it has not been compiled or it is not static.
var needCompile = len(p.PatChars) == 0 || !ast.IsConstant(p.Pattern)
if needCompile {
pattern := p.Pattern.GetDatum()
if pattern.IsNull() {
p.SetNull()
return true
}
spattern, err := pattern.ToString()
if err != nil {
e.err = errors.Trace(err)
return false
}
p.PatChars, p.PatTypes = compilePattern(spattern, p.Escape)
}
match := doMatch(sexpr, p.PatChars, p.PatTypes)
if p.Not {
match = !match
}
p.SetInt64(boolToInt64(match))
return true
}
func (r *preEvaluator) Leave(in ast.Node) (ast.Node, bool) {
if expr, ok := in.(ast.ExprNode); ok {
if _, ok = expr.(*ast.ValueExpr); ok {
return in, true
} else if ast.IsPreEvaluable(expr) {
val, err := evaluator.Eval(r.ctx, expr)
if err != nil {
r.err = err
return in, false
}
if ast.IsConstant(expr) {
// The expression is constant, rewrite the expression to value expression.
valExpr := &ast.ValueExpr{}
valExpr.SetText(expr.Text())
valExpr.SetType(expr.GetType())
valExpr.SetValue(val)
return valExpr, true
}
expr.SetValue(val)
}
}
return in, true
}