Esempio n. 1
0
func (e *Evaluator) handleXor(o *ast.BinaryOperationExpr) bool {
	leftDatum := o.L.GetDatum()
	righDatum := o.R.GetDatum()
	if leftDatum.IsNull() || righDatum.IsNull() {
		o.SetNull()
		return true
	}
	x, err := leftDatum.ToBool(e.sc)
	if err != nil {
		e.err = errors.Trace(err)
		return false
	}

	y, err := righDatum.ToBool(e.sc)
	if err != nil {
		e.err = errors.Trace(err)
		return false
	}
	if x == y {
		o.SetInt64(int64(0))
	} else {
		o.SetInt64(int64(1))
	}
	return true
}
Esempio n. 2
0
func (e *Evaluator) handleOrOr(o *ast.BinaryOperationExpr) bool {
	leftDatum := o.L.GetDatum()
	if !leftDatum.IsNull() {
		x, err := leftDatum.ToBool(e.sc)
		if err != nil {
			e.err = errors.Trace(err)
			return false
		} else if x == 1 {
			// true || any other types is true.
			o.SetInt64(x)
			return true
		}
	}
	righDatum := o.R.GetDatum()
	if !righDatum.IsNull() {
		y, err := righDatum.ToBool(e.sc)
		if err != nil {
			e.err = errors.Trace(err)
			return false
		} else if y == 1 {
			o.SetInt64(y)
			return true
		}
	}
	if leftDatum.IsNull() || righDatum.IsNull() {
		o.SetNull()
		return true
	}
	o.SetInt64(int64(0))
	return true
}
Esempio n. 3
0
func (e *Evaluator) handleAndAnd(o *ast.BinaryOperationExpr) bool {
	leftDatum := o.L.GetDatum()
	rightDatum := o.R.GetDatum()
	if leftDatum.Kind() != types.KindNull {
		x, err := leftDatum.ToBool()
		if err != nil {
			e.err = errors.Trace(err)
			return false
		} else if x == 0 {
			// false && any other types is false
			o.SetInt64(x)
			return true
		}
	}
	if rightDatum.Kind() != types.KindNull {
		y, err := rightDatum.ToBool()
		if err != nil {
			e.err = errors.Trace(err)
			return false
		} else if y == 0 {
			o.SetInt64(y)
			return true
		}
	}
	if leftDatum.Kind() == types.KindNull || rightDatum.Kind() == types.KindNull {
		o.SetNull()
		return true
	}
	o.SetInt64(int64(1))
	return true
}
Esempio n. 4
0
func (e *Evaluator) handleComparisonOp(o *ast.BinaryOperationExpr) bool {
	var a, b = *o.L.GetDatum(), *o.R.GetDatum()
	var err error
	if o.Op != opcode.NullEQ {
		a, b, err = types.CoerceDatum(e.sc, *o.L.GetDatum(), *o.R.GetDatum())
		if err != nil {
			e.err = errors.Trace(err)
			return false
		}
	}
	if a.IsNull() || b.IsNull() {
		// for <=>, if a and b are both nil, return true.
		// if a or b is nil, return false.
		if o.Op == opcode.NullEQ {
			if a.IsNull() && b.IsNull() {
				o.SetInt64(oneI64)
			} else {
				o.SetInt64(zeroI64)
			}
		} else {
			o.SetNull()
		}
		return true
	}

	n, err := a.CompareDatum(e.sc, 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.SetInt64(oneI64)
	} else {
		o.SetInt64(zeroI64)
	}
	return true
}