func (e *Evaluator) handleComparisonOp(o *ast.BinaryOperationExpr) bool { a, b := types.Coerce(o.L.GetValue(), o.R.GetValue()) if types.IsNil(a) || types.IsNil(b) { // for <=>, if a and b are both nil, return true. // if a or b is nil, return false. if o.Op == opcode.NullEQ { if types.IsNil(a) || types.IsNil(b) { o.SetValue(oneI64) } else { o.SetValue(zeroI64) } } else { o.SetValue(nil) } return true } n, err := types.Compare(a, b) if err != nil { e.err = errors.Trace(err) return false } r, err := getCompResult(o.Op, n) if err != nil { e.err = errors.Trace(err) return false } if r { o.SetValue(oneI64) } else { o.SetValue(zeroI64) } return true }
func (e *Evaluator) handleOrOr(o *ast.BinaryOperationExpr) bool { leftVal := o.L.GetValue() righVal := o.R.GetValue() if !types.IsNil(leftVal) { x, err := types.ToBool(leftVal) if err != nil { e.err = errors.Trace(err) return false } else if x == 1 { // true || any other types is true. o.SetValue(x) return true } } if !types.IsNil(righVal) { y, err := types.ToBool(righVal) if err != nil { e.err = errors.Trace(err) return false } else if y == 1 { o.SetValue(y) return true } } if types.IsNil(leftVal) || types.IsNil(righVal) { o.SetValue(nil) return true } o.SetValue(int64(0)) return true }
func (e *Evaluator) binaryOperation(o *ast.BinaryOperationExpr) bool { // all operands must have same column. if e.err = hasSameColumnCount(o.L, o.R); e.err != nil { return false } // row constructor only supports comparison operation. switch o.Op { case opcode.LT, opcode.LE, opcode.GE, opcode.GT, opcode.EQ, opcode.NE, opcode.NullEQ: default: if !checkAllOneColumn(o.L) { e.err = errors.Errorf("Operand should contain 1 column(s)") return false } } leftVal, err := types.Convert(o.L.GetValue(), o.GetType()) if err != nil { e.err = err return false } rightVal, err := types.Convert(o.R.GetValue(), o.GetType()) if err != nil { e.err = err return false } if leftVal == nil || rightVal == nil { o.SetValue(nil) return true } switch o.Op { case opcode.AndAnd, opcode.OrOr, opcode.LogicXor: return e.handleLogicOperation(o) case opcode.LT, opcode.LE, opcode.GE, opcode.GT, opcode.EQ, opcode.NE, opcode.NullEQ: return e.handleComparisonOp(o) case opcode.RightShift, opcode.LeftShift, opcode.And, opcode.Or, opcode.Xor: // TODO: MySQL doesn't support and not, we should remove it later. return e.handleBitOp(o) case opcode.Plus, opcode.Minus, opcode.Mod, opcode.Div, opcode.Mul, opcode.IntDiv: return e.handleArithmeticOp(o) default: panic("should never happen") } }
func (e *Evaluator) handleArithmeticOp(o *ast.BinaryOperationExpr) bool { a, err := coerceArithmetic(o.L.GetValue()) if err != nil { e.err = err return false } b, err := coerceArithmetic(o.R.GetValue()) if err != nil { e.err = err return false } a, b = types.Coerce(a, b) if a == nil || b == nil { // TODO: for <=>, if a and b are both nil, return true o.SetValue(nil) return true } // TODO: support logic division DIV var result interface{} switch o.Op { case opcode.Plus: result, e.err = computePlus(a, b) case opcode.Minus: result, e.err = computeMinus(a, b) case opcode.Mul: result, e.err = computeMul(a, b) case opcode.Div: result, e.err = computeDiv(a, b) case opcode.Mod: result, e.err = computeMod(a, b) case opcode.IntDiv: result, e.err = computeIntDiv(a, b) default: e.err = errors.Errorf("invalid op %v in arithmetic operation", o.Op) return false } o.SetValue(result) return e.err == nil }
func (e *Evaluator) handleArithmeticOp(o *ast.BinaryOperationExpr) bool { a, err := coerceArithmetic(types.RawData(o.L.GetValue())) if err != nil { e.err = errors.Trace(err) return false } b, err := coerceArithmetic(types.RawData(o.R.GetValue())) if err != nil { e.err = errors.Trace(err) return false } a, b = types.Coerce(a, b) if a == nil || b == nil { o.SetValue(nil) return true } var result interface{} switch o.Op { case opcode.Plus: result, e.err = computePlus(a, b) case opcode.Minus: result, e.err = computeMinus(a, b) case opcode.Mul: result, e.err = computeMul(a, b) case opcode.Div: result, e.err = computeDiv(a, b) case opcode.Mod: result, e.err = computeMod(a, b) case opcode.IntDiv: result, e.err = computeIntDiv(a, b) default: e.err = ErrInvalidOperation.Gen("invalid op %v in arithmetic operation", o.Op) return false } o.SetValue(result) return e.err == nil }
func (e *Evaluator) handleXor(o *ast.BinaryOperationExpr) bool { leftVal := o.L.GetValue() righVal := o.R.GetValue() if types.IsNil(leftVal) || types.IsNil(righVal) { o.SetValue(nil) return true } x, err := types.ToBool(leftVal) if err != nil { e.err = errors.Trace(err) return false } y, err := types.ToBool(righVal) if err != nil { e.err = errors.Trace(err) return false } if x == y { o.SetValue(int64(0)) } else { o.SetValue(int64(1)) } return true }
func (e *Evaluator) handleLogicOperation(o *ast.BinaryOperationExpr) bool { leftVal, err := types.Convert(o.L.GetValue(), o.GetType()) if err != nil { e.err = err return false } rightVal, err := types.Convert(o.R.GetValue(), o.GetType()) if err != nil { e.err = err return false } if leftVal == nil || rightVal == nil { o.SetValue(nil) return true } var boolVal bool switch o.Op { case opcode.AndAnd: boolVal = leftVal != zeroI64 && rightVal != zeroI64 case opcode.OrOr: boolVal = leftVal != zeroI64 || rightVal != zeroI64 case opcode.LogicXor: boolVal = (leftVal == zeroI64 && rightVal != zeroI64) || (leftVal != zeroI64 && rightVal == zeroI64) default: panic("should never happen") } if boolVal { o.SetValue(oneI64) } else { o.SetValue(zeroI64) } return true }
func (e *Evaluator) handleBitOp(o *ast.BinaryOperationExpr) bool { a, b := types.Coerce(o.L.GetValue(), o.R.GetValue()) if types.IsNil(a) || types.IsNil(b) { o.SetValue(nil) return true } x, err := types.ToInt64(a) if err != nil { e.err = errors.Trace(err) return false } y, err := types.ToInt64(b) if err != nil { e.err = errors.Trace(err) return false } // use a int64 for bit operator, return uint64 switch o.Op { case opcode.And: o.SetValue(uint64(x & y)) case opcode.Or: o.SetValue(uint64(x | y)) case opcode.Xor: o.SetValue(uint64(x ^ y)) case opcode.RightShift: o.SetValue(uint64(x) >> uint64(y)) case opcode.LeftShift: o.SetValue(uint64(x) << uint64(y)) default: e.err = ErrInvalidOperation.Gen("invalid op %v in bit operation", o.Op) return false } return true }