add decimal truncation

Author: James Cor

enginetest/queries/script_queries.go

@@ -385,12 +385,11 @@ var ScriptTests = []ScriptTest{
 			},
 			{
 				// TODO: 123.456 is converted to a DECIMAL by Builder.ConvertVal, when it should be a DOUBLE
-				Skip:                            true,
 				Query:                           "SELECT -'+123.456ABC' = -123.456",
 				Expected:                        []sql.Row{{true}},
 				ExpectedWarningsCount:           1,
 				ExpectedWarning:                 mysql.ERTruncatedWrongValue,
-				ExpectedWarningMessageSubstring: "Truncated incorrect double value: +123.456ABC",
+				ExpectedWarningMessageSubstring: "Truncated incorrect decimal(65,30) value: +123.456ABC",
 			},
 			{
 				Query:                           "SELECT '0xBEEF' = 0;",
@@ -457,12 +456,11 @@ var ScriptTests = []ScriptTest{
 			},
 			{
 				// TODO: 123.456 is converted to a DECIMAL by Builder.ConvertVal, when it should be a DOUBLE
-				Skip:                            true,
 				Query:                           "SELECT '123.456ABC' in (123.456);",
 				Expected:                        []sql.Row{{true}},
 				ExpectedWarningsCount:           1,
 				ExpectedWarning:                 mysql.ERTruncatedWrongValue,
-				ExpectedWarningMessageSubstring: "Truncated incorrect double value: 123A",
+				ExpectedWarningMessageSubstring: "Truncated incorrect decimal(65,30) value: 123.456ABC",
 			},
 			{
 				Query:    "SELECT '123.456e2' in (12345.6);",

sql/expression/arithmetic.go

@@ -691,9 +691,12 @@ func (e *UnaryMinus) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	}
 
 	if !types.IsNumber(e.Child.Type()) {
-		child, err = decimal.NewFromString(fmt.Sprintf("%v", child))
+		child, _, err = types.InternalDecimalType.Convert(ctx, child)
 		if err != nil {
-			child = 0.0
+			if !sql.ErrTruncatedIncorrect.Is(err) {
+				child = 0.0
+			}
+			ctx.Warn(mysql.ERTruncatedWrongValue, "%s", err.Error())
 		}
 	}
 
@@ -735,7 +738,7 @@ func (e *UnaryMinus) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	case uint64:
 		return -int64(n), nil
 	case decimal.Decimal:
-		return n.Neg(), err
+		return n.Neg(), nil
 	case string:
 		// try getting int out of string value
 		i, iErr := strconv.ParseInt(n, 10, 64)

sql/expression/convert.go

@@ -356,7 +356,10 @@ func convertValue(ctx *sql.Context, val interface{}, castTo string, originType s
 		dt := createConvertedDecimalType(typeLength, typeScale, false)
 		d, _, err := dt.Convert(ctx, value)
 		if err != nil {
-			return dt.Zero(), nil
+			if !sql.ErrTruncatedIncorrect.Is(err) {
+				return dt.Zero(), nil
+			}
+			ctx.Warn(mysql.ERTruncatedWrongValue, "%s", err.Error())
 		}
 		return d, nil
 	case ConvertToFloat:
@@ -376,11 +379,10 @@ func convertValue(ctx *sql.Context, val interface{}, castTo string, originType s
 		}
 		d, _, err := types.Float64.Convert(ctx, value)
 		if err != nil {
-			if sql.ErrTruncatedIncorrect.Is(err) {
-				ctx.Warn(mysql.ERTruncatedWrongValue, "%s", err.Error())
-				return d, nil
+			if !sql.ErrTruncatedIncorrect.Is(err) {
+				return types.Float64.Zero(), nil
 			}
-			return types.Float64.Zero(), nil
+			ctx.Warn(mysql.ERTruncatedWrongValue, "%s", err.Error())
 		}
 		return d, nil
 	case ConvertToJSON:

sql/types/decimal.go

@@ -17,16 +17,14 @@ package types
 import (
 	"context"
 	"fmt"
-	"math/big"
-	"reflect"
-	"strings"
-
+	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/dolthub/vitess/go/vt/proto/query"
 	"github.com/shopspring/decimal"
 	"gopkg.in/src-d/go-errors.v1"
-
-	"github.com/dolthub/go-mysql-server/sql"
+	"math/big"
+	"reflect"
+	"strings"
 )
 
 const (
@@ -141,13 +139,17 @@ func (t DecimalType_) Compare(s context.Context, a interface{}, b interface{}) (
 // Convert implements Type interface.
 func (t DecimalType_) Convert(c context.Context, v interface{}) (interface{}, sql.ConvertInRange, error) {
 	dec, err := t.ConvertToNullDecimal(v)
-	if err != nil {
+	if err != nil && !sql.ErrTruncatedIncorrect.Is(err) {
 		return nil, sql.OutOfRange, err
 	}
 	if !dec.Valid {
 		return nil, sql.InRange, nil
 	}
-	return t.BoundsCheck(dec.Decimal)
+	res, inRange, cErr := t.BoundsCheck(dec.Decimal)
+	if cErr != nil {
+		return nil, sql.OutOfRange, cErr
+	}
+	return res, inRange, err
 }
 
 func (t DecimalType_) ConvertNoBoundsCheck(v interface{}) (decimal.Decimal, error) {
@@ -201,25 +203,33 @@ func (t DecimalType_) ConvertToNullDecimal(v interface{}) (decimal.NullDecimal,
 	case float64:
 		return t.ConvertToNullDecimal(decimal.NewFromFloat(value))
 	case string:
-		// TODO: implement truncation here
-		value = strings.Trim(value, sql.NumericCutSet)
-		if len(value) == 0 {
-			return t.ConvertToNullDecimal(decimal.NewFromInt(0))
-		}
 		var err error
-		res, err = decimal.NewFromString(value)
-		if err != nil {
-			// The decimal library cannot handle all of the different formats
-			bf, _, err := new(big.Float).SetPrec(217).Parse(value, 0)
-			if err != nil {
-				return decimal.NullDecimal{}, err
-			}
+		truncStr := strings.Trim(value, sql.NumericCutSet)
+		res, err = decimal.NewFromString(truncStr)
+		if err == nil {
+			return t.ConvertToNullDecimal(res)
+		}
+		// The decimal library cannot handle all the different formats
+		bf, _, err := new(big.Float).SetPrec(217).Parse(truncStr, 0)
+		if err == nil {
 			res, err = decimal.NewFromString(bf.Text('f', -1))
-			if err != nil {
-				return decimal.NullDecimal{}, err
+			if err == nil {
+				return t.ConvertToNullDecimal(res)
 			}
 		}
-		return t.ConvertToNullDecimal(res)
+		truncStr, didTrunc := sql.TruncateStringToDouble(value)
+		if truncStr == "0" {
+			return t.ConvertToNullDecimal(decimal.NewFromInt(0))
+		}
+		res, _ = decimal.NewFromString(truncStr)
+		nullDec, cErr := t.ConvertToNullDecimal(res)
+		if cErr != nil {
+			return decimal.NullDecimal{}, cErr
+		}
+		if didTrunc {
+			err = sql.ErrTruncatedIncorrect.New(t, value)
+		}
+		return nullDec, err
 	case *big.Float:
 		return t.ConvertToNullDecimal(value.Text('f', -1))
 	case *big.Int: