expression: separated arithmeticIntDivideSig

expression/builtin_arithmetic.go

@@ -48,7 +48,10 @@ var (
 	_ builtinFunc = &builtinArithmeticMultiplyDecimalSig{}
 	_ builtinFunc = &builtinArithmeticMultiplyIntUnsignedSig{}
 	_ builtinFunc = &builtinArithmeticMultiplyIntSig{}
-	_ builtinFunc = &builtinArithmeticIntDivideIntSig{}
+	_ builtinFunc = &builtinArithmeticIntDivideIntUnsignedUnsignedSig{}
+	_ builtinFunc = &builtinArithmeticIntDivideIntUnsignedSignedSig{}
+	_ builtinFunc = &builtinArithmeticIntDivideIntSignedSignedSig{}
+	_ builtinFunc = &builtinArithmeticIntDivideIntSignedUnsignedSig{}
 	_ builtinFunc = &builtinArithmeticIntDivideDecimalSig{}
 	_ builtinFunc = &builtinArithmeticModIntSig{}
 	_ builtinFunc = &builtinArithmeticModRealSig{}
@@ -711,12 +714,30 @@ func (c *arithmeticIntDivideFunctionClass) getFunction(ctx sessionctx.Context, a
 		if err != nil {
 			return nil, err
 		}
-		if mysql.HasUnsignedFlag(lhsTp.Flag) || mysql.HasUnsignedFlag(rhsTp.Flag) {
+		isLHSUnsigned := mysql.HasUnsignedFlag(args[0].GetType().Flag)
+		isRHSUnsigned := mysql.HasUnsignedFlag(args[1].GetType().Flag)
+		if isLHSUnsigned || isRHSUnsigned {
 			bf.tp.Flag |= mysql.UnsignedFlag
 		}
-		sig := &builtinArithmeticIntDivideIntSig{bf}
-		sig.setPbCode(tipb.ScalarFuncSig_IntDivideInt)
-		return sig, nil
+
+		switch {
+		case isLHSUnsigned && isRHSUnsigned:
+			sig := &builtinArithmeticIntDivideIntUnsignedUnsignedSig{bf}
+			sig.setPbCode(tipb.ScalarFuncSig_IntDivideIntUnsignedUnsigned)
+			return sig, nil
+		case isLHSUnsigned && !isRHSUnsigned:
+			sig := &builtinArithmeticIntDivideIntUnsignedSignedSig{bf}
+			sig.setPbCode(tipb.ScalarFuncSig_IntDivideIntUnsignedSigned)
+			return sig, nil
+		case !isLHSUnsigned && isRHSUnsigned:
+			sig := &builtinArithmeticIntDivideIntSignedUnsignedSig{bf}
+			sig.setPbCode(tipb.ScalarFuncSig_IntDivideIntSignedUnsigned)
+			return sig, nil
+		default:
+			sig := &builtinArithmeticIntDivideIntSignedSignedSig{bf}
+			sig.setPbCode(tipb.ScalarFuncSig_IntDivideIntSignedSigned)
+			return sig, nil
+		}
 	}
 	bf, err := newBaseBuiltinFuncWithTp(ctx, c.funcName, args, types.ETInt, types.ETDecimal, types.ETDecimal)
 	if err != nil {
@@ -730,27 +751,55 @@ func (c *arithmeticIntDivideFunctionClass) getFunction(ctx sessionctx.Context, a
 	return sig, nil
 }
 
-type builtinArithmeticIntDivideIntSig struct{ baseBuiltinFunc }
+type builtinArithmeticIntDivideIntUnsignedUnsignedSig struct {
+	baseBuiltinFunc
+}
 
-func (s *builtinArithmeticIntDivideIntSig) Clone() builtinFunc {
-	newSig := &builtinArithmeticIntDivideIntSig{}
+func (s *builtinArithmeticIntDivideIntUnsignedUnsignedSig) Clone() builtinFunc {
+	newSig := &builtinArithmeticIntDivideIntUnsignedUnsignedSig{}
 	newSig.cloneFrom(&s.baseBuiltinFunc)
 	return newSig
 }
 
-type builtinArithmeticIntDivideDecimalSig struct{ baseBuiltinFunc }
+func (s *builtinArithmeticIntDivideIntUnsignedUnsignedSig) evalInt(row chunk.Row) (int64, bool, error) {
+	return s.evalIntWithCtx(s.ctx, row)
+}
 
-func (s *builtinArithmeticIntDivideDecimalSig) Clone() builtinFunc {
-	newSig := &builtinArithmeticIntDivideDecimalSig{}
+func (s *builtinArithmeticIntDivideIntUnsignedUnsignedSig) evalIntWithCtx(sctx sessionctx.Context, row chunk.Row) (int64, bool, error) {
+	b, isNull, err := s.args[1].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+
+	if b == 0 {
+		return 0, true, handleDivisionByZeroError(sctx)
+	}
+
+	a, isNull, err := s.args[0].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+
+	ret := int64(uint64(a) / uint64(b))
+
+	return ret, false, nil
+}
+
+type builtinArithmeticIntDivideIntSignedUnsignedSig struct {
+	baseBuiltinFunc
+}
+
+func (s *builtinArithmeticIntDivideIntSignedUnsignedSig) Clone() builtinFunc {
+	newSig := &builtinArithmeticIntDivideIntSignedUnsignedSig{}
 	newSig.cloneFrom(&s.baseBuiltinFunc)
 	return newSig
 }
 
-func (s *builtinArithmeticIntDivideIntSig) evalInt(row chunk.Row) (int64, bool, error) {
+func (s *builtinArithmeticIntDivideIntSignedUnsignedSig) evalInt(row chunk.Row) (int64, bool, error) {
 	return s.evalIntWithCtx(s.ctx, row)
 }
 
-func (s *builtinArithmeticIntDivideIntSig) evalIntWithCtx(sctx sessionctx.Context, row chunk.Row) (int64, bool, error) {
+func (s *builtinArithmeticIntDivideIntSignedUnsignedSig) evalIntWithCtx(sctx sessionctx.Context, row chunk.Row) (int64, bool, error) {
 	b, isNull, err := s.args[1].EvalInt(sctx, row)
 	if isNull || err != nil {
 		return 0, isNull, err
@@ -765,29 +814,87 @@ func (s *builtinArithmeticIntDivideIntSig) evalIntWithCtx(sctx sessionctx.Contex
 		return 0, isNull, err
 	}
 
-	var (
-		ret int64
-		val uint64
-	)
-	isLHSUnsigned := mysql.HasUnsignedFlag(s.args[0].GetType().Flag)
-	isRHSUnsigned := mysql.HasUnsignedFlag(s.args[1].GetType().Flag)
+	val, err := types.DivIntWithUint(a, uint64(b))
 
-	switch {
-	case isLHSUnsigned && isRHSUnsigned:
-		ret = int64(uint64(a) / uint64(b))
-	case isLHSUnsigned && !isRHSUnsigned:
-		val, err = types.DivUintWithInt(uint64(a), b)
-		ret = int64(val)
-	case !isLHSUnsigned && isRHSUnsigned:
-		val, err = types.DivIntWithUint(a, uint64(b))
-		ret = int64(val)
-	case !isLHSUnsigned && !isRHSUnsigned:
-		ret, err = types.DivInt64(a, b)
+	return int64(val), err != nil, err
+}
+
+type builtinArithmeticIntDivideIntSignedSignedSig struct {
+	baseBuiltinFunc
+}
+
+func (s *builtinArithmeticIntDivideIntSignedSignedSig) Clone() builtinFunc {
+	newSig := &builtinArithmeticIntDivideIntSignedSignedSig{}
+	newSig.cloneFrom(&s.baseBuiltinFunc)
+	return newSig
+}
+
+func (s *builtinArithmeticIntDivideIntSignedSignedSig) evalInt(row chunk.Row) (int64, bool, error) {
+	return s.evalIntWithCtx(s.ctx, row)
+}
+
+func (s *builtinArithmeticIntDivideIntSignedSignedSig) evalIntWithCtx(sctx sessionctx.Context, row chunk.Row) (int64, bool, error) {
+	b, isNull, err := s.args[1].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+
+	if b == 0 {
+		return 0, true, handleDivisionByZeroError(sctx)
+	}
+
+	a, isNull, err := s.args[0].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
 	}
 
+	ret, err := types.DivInt64(a, b)
+
 	return ret, err != nil, err
 }
 
+type builtinArithmeticIntDivideIntUnsignedSignedSig struct {
+	baseBuiltinFunc
+}
+
+func (s *builtinArithmeticIntDivideIntUnsignedSignedSig) Clone() builtinFunc {
+	newSig := &builtinArithmeticIntDivideIntUnsignedSignedSig{}
+	newSig.cloneFrom(&s.baseBuiltinFunc)
+	return newSig
+}
+
+func (s *builtinArithmeticIntDivideIntUnsignedSignedSig) evalInt(row chunk.Row) (int64, bool, error) {
+	return s.evalIntWithCtx(s.ctx, row)
+}
+
+func (s *builtinArithmeticIntDivideIntUnsignedSignedSig) evalIntWithCtx(sctx sessionctx.Context, row chunk.Row) (int64, bool, error) {
+	b, isNull, err := s.args[1].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+
+	if b == 0 {
+		return 0, true, handleDivisionByZeroError(sctx)
+	}
+
+	a, isNull, err := s.args[0].EvalInt(sctx, row)
+	if isNull || err != nil {
+		return 0, isNull, err
+	}
+
+	val, err := types.DivUintWithInt(uint64(a), b)
+
+	return int64(val), err != nil, err
+}
+
+type builtinArithmeticIntDivideDecimalSig struct{ baseBuiltinFunc }
+
+func (s *builtinArithmeticIntDivideDecimalSig) Clone() builtinFunc {
+	newSig := &builtinArithmeticIntDivideDecimalSig{}
+	newSig.cloneFrom(&s.baseBuiltinFunc)
+	return newSig
+}
+
 func (s *builtinArithmeticIntDivideDecimalSig) evalInt(row chunk.Row) (ret int64, isNull bool, err error) {
 	sc := s.ctx.GetSessionVars().StmtCtx
 	var num [2]*types.MyDecimal

expression/builtin_arithmetic_test.go

@@ -367,10 +367,12 @@ func (s *testEvaluatorSuite) TestArithmeticDivide(c *C) {
 		c.Assert(err, IsNil)
 		c.Assert(sig, NotNil)
 		switch sig.(type) {
-		case *builtinArithmeticIntDivideIntSig:
-			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideInt)
-		case *builtinArithmeticIntDivideDecimalSig:
-			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideDecimal)
+		case *builtinArithmeticDivideRealSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_DivideReal)
+		case *builtinArithmeticDivideDecimalSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_DivideDecimal)
+		default:
+			panic("Wrong type of signature tested")
 		}
 		val, err := evalBuiltinFunc(sig, chunk.Row{})
 		c.Assert(err, IsNil)
@@ -475,12 +477,34 @@ func (s *testEvaluatorSuite) TestArithmeticIntDivide(c *C) {
 			args:   []interface{}{uint64(1), float64(-1)},
 			expect: []interface{}{nil, "*BIGINT UNSIGNED value is out of range in '\\(1 DIV -1\\)'"},
 		},
+		{
+			args:   []interface{}{uint64(3), -3},
+			expect: []interface{}{nil, "*BIGINT UNSIGNED value is out of range in '\\(3, -3\\)'"},
+		},
+		{
+			args:   []interface{}{-3, uint64(3)},
+			expect: []interface{}{nil, "*BIGINT value is out of range in '\\(-3, 3\\)'"},
+		},
 	}
 
 	for _, tc := range testCases {
 		sig, err := funcs[ast.IntDiv].getFunction(s.ctx, s.datumsToConstants(types.MakeDatums(tc.args...)))
 		c.Assert(err, IsNil)
 		c.Assert(sig, NotNil)
+		switch sig.(type) {
+		case *builtinArithmeticIntDivideIntSignedUnsignedSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideIntSignedUnsigned)
+		case *builtinArithmeticIntDivideIntSignedSignedSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideIntSignedSigned)
+		case *builtinArithmeticIntDivideIntUnsignedSignedSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideIntUnsignedSigned)
+		case *builtinArithmeticIntDivideIntUnsignedUnsignedSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideIntUnsignedUnsigned)
+		case *builtinArithmeticIntDivideDecimalSig:
+			c.Assert(sig.PbCode(), Equals, tipb.ScalarFuncSig_IntDivideDecimal)
+		default:
+			panic("Wrong type of signature tested")
+		}
 		val, err := evalBuiltinFunc(sig, chunk.Row{})
 		if tc.expect[1] == nil {
 			c.Assert(err, IsNil)