Moved decimal type

zachmu · zachmu · commit 97c346b61712 · 2022-12-29T15:40:00.000-08:00
diff --git a/enginetest/queries/script_queries.go b/enginetest/queries/script_queries.go
@@ -1691,7 +1691,7 @@ var ScriptTests = []ScriptTest{
 			},
 			{
 				Query:       "INSERT INTO small_test VALUES (12.1);",
-				ExpectedErr: sql.ErrConvertToDecimalLimit,
+				ExpectedErr: types.ErrConvertToDecimalLimit,
 			},
 		},
 	},
diff --git a/server/handler.go b/server/handler.go
@@ -226,11 +226,11 @@ func bindingsToExprs(bindings map[string]*query.BindVariable) (map[string]sql.Ex
 			}
 			res[k] = expression.NewLiteral(c, t)
 		case v.Type() == sqltypes.Decimal:
-			v, err := sql.InternalDecimalType.Convert(string(v.ToBytes()))
+			v, err := types.InternalDecimalType.Convert(string(v.ToBytes()))
 			if err != nil {
 				return nil, err
 			}
-			res[k] = expression.NewLiteral(v, sql.InternalDecimalType)
+			res[k] = expression.NewLiteral(v, types.InternalDecimalType)
 		case v.Type() == sqltypes.Bit:
 			t := sql.MustCreateBitType(sql.BitTypeMaxBits)
 			v, err := t.Convert(v.ToBytes())
diff --git a/server/handler_test.go b/server/handler_test.go
@@ -601,8 +601,8 @@ func TestSchemaToFields(t *testing.T) {
 		// Floating Point and Decimal Types
 		{Name: "float32", Type: types.Float32},
 		{Name: "float64", Type: types.Float64},
-		{Name: "decimal10_0", Type: sql.MustCreateDecimalType(10, 0)},
-		{Name: "decimal60_30", Type: sql.MustCreateDecimalType(60, 30)},
+		{Name: "decimal10_0", Type: types.MustCreateDecimalType(10, 0)},
+		{Name: "decimal60_30", Type: types.MustCreateDecimalType(60, 30)},
 
 		// Char, Binary, and Bit Types
 		{Name: "varchar50", Type: types.MustCreateString(sqltypes.VarChar, 50, sql.Collation_Default)},
diff --git a/sql/analyzer/resolve_external_stored_procedures.go b/sql/analyzer/resolve_external_stored_procedures.go
@@ -52,7 +52,7 @@ var (
 		reflect.TypeOf(string("")):        types.LongText,
 		reflect.TypeOf([]byte{}):          types.LongBlob,
 		reflect.TypeOf(time.Time{}):       types.Datetime,
-		reflect.TypeOf(decimal.Decimal{}): sql.InternalDecimalType,
+		reflect.TypeOf(decimal.Decimal{}): types.InternalDecimalType,
 	}
 	// externalStoredProcedurePointerTypes maps a pointer type to a sql.Type for external stored procedures.
 	externalStoredProcedurePointerTypes = map[reflect.Type]sql.Type{
@@ -72,7 +72,7 @@ var (
 		reflect.TypeOf((*string)(nil)):          types.LongText,
 		reflect.TypeOf((*[]byte)(nil)):          types.LongBlob,
 		reflect.TypeOf((*time.Time)(nil)):       types.Datetime,
-		reflect.TypeOf((*decimal.Decimal)(nil)): sql.InternalDecimalType,
+		reflect.TypeOf((*decimal.Decimal)(nil)): types.InternalDecimalType,
 	}
 )
 
diff --git a/sql/expression/case.go b/sql/expression/case.go
@@ -69,11 +69,11 @@ func combinedCaseBranchType(left, right sql.Type) sql.Type {
 			return types.Float32
 		}
 		if types.IsDecimal(left) || types.IsDecimal(right) {
-			return sql.MustCreateDecimalType(65, 10)
+			return types.MustCreateDecimalType(65, 10)
 		}
 		if left == types.Uint64 && types.IsSigned(right) ||
 			right == types.Uint64 && types.IsSigned(left) {
-			return sql.MustCreateDecimalType(65, 10)
+			return types.MustCreateDecimalType(65, 10)
 		}
 		if !types.IsSigned(left) && !types.IsSigned(right) {
 			return types.Uint64
diff --git a/sql/expression/case_test.go b/sql/expression/case_test.go
@@ -161,7 +161,7 @@ func TestCaseType(t *testing.T) {
 		}
 	}
 
-	decimalType := sql.MustCreateDecimalType(65, 10)
+	decimalType := types.MustCreateDecimalType(65, 10)
 
 	testCases := []struct {
 		name string
diff --git a/sql/expression/convert.go b/sql/expression/convert.go
@@ -95,7 +95,7 @@ func (c *Convert) Type() sql.Type {
 		return types.Datetime
 	case ConvertToDecimal:
 		//TODO: these values are completely arbitrary, we need to get the given precision/scale and store it
-		return sql.MustCreateDecimalType(65, 10)
+		return types.MustCreateDecimalType(65, 10)
 	case ConvertToDouble, ConvertToReal:
 		return types.Float64
 	case ConvertToJSON:
@@ -215,7 +215,7 @@ func convertValue(val interface{}, castTo string, originType sql.Type) (interfac
 		if err != nil {
 			return nil, err
 		}
-		d, err := sql.InternalDecimalType.Convert(value)
+		d, err := types.InternalDecimalType.Convert(value)
 		if err != nil {
 			return "0", nil
 		}
diff --git a/sql/expression/div.go b/sql/expression/div.go
@@ -150,8 +150,8 @@ func (d *Div) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	if isOutermostDiv(d, 0, d.divScale) {
 		if res, ok := result.(decimal.Decimal); ok {
 			finalScale := d.divScale*int32(divPrecisionIncrement) + d.leftmostScale
-			if finalScale > sql.DecimalTypeMaxScale {
-				finalScale = sql.DecimalTypeMaxScale
+			if finalScale > types.DecimalTypeMaxScale {
+				finalScale = types.DecimalTypeMaxScale
 			}
 			if isOutermostArithmeticOp(d, 0, d.ops) {
 				return res.Round(finalScale), nil
@@ -315,9 +315,9 @@ func floatOrDecimalType(e sql.Expression) sql.Type {
 	}
 
 	// defType is defined by evaluating all number literals available
-	defType, derr := sql.CreateDecimalType(maxWhole+maxFrac, maxFrac)
+	defType, derr := types.CreateDecimalType(maxWhole+maxFrac, maxFrac)
 	if derr != nil {
-		return sql.MustCreateDecimalType(65, 10)
+		return types.MustCreateDecimalType(65, 10)
 	}
 
 	return defType
@@ -334,7 +334,7 @@ func convertToDecimalValue(val interface{}, isTimeType bool) interface{} {
 
 	if _, ok := val.(decimal.Decimal); !ok {
 		p, s := GetPrecisionAndScale(val)
-		dtyp, err := sql.CreateDecimalType(p, s)
+		dtyp, err := types.CreateDecimalType(p, s)
 		if err != nil {
 			val = decimal.Zero
 		}
@@ -605,7 +605,7 @@ func (i *IntDiv) Type() sql.Type {
 	}
 
 	// using max precision which is 65.
-	defType := sql.MustCreateDecimalType(65, 0)
+	defType := types.MustCreateDecimalType(65, 0)
 	return defType
 }
 
diff --git a/sql/expression/function/absval_test.go b/sql/expression/function/absval_test.go
@@ -28,7 +28,7 @@ import (
 func TestAbsValue(t *testing.T) {
 	type toTypeFunc func(float64) interface{}
 
-	decimal1616 := sql.MustCreateDecimalType(16, 16)
+	decimal1616 := types.MustCreateDecimalType(16, 16)
 
 	toInt64 := func(x float64) interface{} { return int64(x) }
 	toInt32 := func(x float64) interface{} { return int32(x) }
diff --git a/sql/information_schema/information_schema.go b/sql/information_schema/information_schema.go
@@ -462,9 +462,9 @@ var profilingSchema = Schema{
 	{Name: "QUERY_ID", Type: types.Int32, Default: nil, Nullable: false, Source: ProfilingTableName},
 	{Name: "SEQ", Type: types.Int32, Default: nil, Nullable: false, Source: ProfilingTableName},
 	{Name: "STATE", Type: types.MustCreateStringWithDefaults(sqltypes.VarChar, 30), Default: nil, Nullable: false, Source: ProfilingTableName},
-	{Name: "DURATION", Type: MustCreateDecimalType(DecimalTypeMaxPrecision, 0), Default: nil, Nullable: false, Source: ProfilingTableName},
-	{Name: "CPU_USER", Type: MustCreateDecimalType(DecimalTypeMaxPrecision, 0), Default: nil, Nullable: true, Source: ProfilingTableName},
-	{Name: "CPU_SYSTEM", Type: MustCreateDecimalType(DecimalTypeMaxPrecision, 0), Default: nil, Nullable: true, Source: ProfilingTableName},
+	{Name: "DURATION", Type: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, 0), Default: nil, Nullable: false, Source: ProfilingTableName},
+	{Name: "CPU_USER", Type: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, 0), Default: nil, Nullable: true, Source: ProfilingTableName},
+	{Name: "CPU_SYSTEM", Type: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, 0), Default: nil, Nullable: true, Source: ProfilingTableName},
 	{Name: "CONTEXT_VOLUNTARY", Type: types.Int32, Default: nil, Nullable: true, Source: ProfilingTableName},
 	{Name: "CONTEXT_INVOLUNTARY", Type: types.Int32, Default: nil, Nullable: true, Source: ProfilingTableName},
 	{Name: "BLOCK_OPS_IN", Type: types.Int32, Default: nil, Nullable: true, Source: ProfilingTableName},
diff --git a/sql/parse/parse.go b/sql/parse/parse.go
@@ -3647,7 +3647,7 @@ func convertVal(ctx *sql.Context, v *sqlparser.SQLVal) (sql.Expression, error) {
 			floatVal := fmt.Sprintf("%v", val)
 			if len(ogVal) >= len(floatVal) && ogVal != floatVal {
 				p, s := expression.GetDecimalPrecisionAndScale(ogVal)
-				dt, err := sql.CreateDecimalType(p, s)
+				dt, err := types.CreateDecimalType(p, s)
 				if err != nil {
 					return expression.NewLiteral(string(v.Val), types.CreateLongText(ctx.GetCollation())), nil
 				}
diff --git a/sql/parse/parse_test.go b/sql/parse/parse_test.go
@@ -2049,7 +2049,7 @@ CREATE TABLE t2
 		{
 			input: `INSERT INTO test (decimal_col) VALUES (11981.5923291839784651)`,
 			plan: plan.NewInsertInto(sql.UnresolvedDatabase(""), plan.NewUnresolvedTable("test", ""), plan.NewValues([][]sql.Expression{{
-				expression.NewLiteral(decimal.RequireFromString("11981.5923291839784651"), sql.MustCreateDecimalType(21, 16)),
+				expression.NewLiteral(decimal.RequireFromString("11981.5923291839784651"), types.MustCreateDecimalType(21, 16)),
 			}}), false, []string{"decimal_col"}, []sql.Expression{}, false),
 		},
 		{
@@ -2770,8 +2770,8 @@ CREATE TABLE t2
 				[]sql.Expression{
 					expression.NewAlias("1.0 * a + 2.0 * b",
 						expression.NewPlus(
-							expression.NewMult(expression.NewLiteral(decimal.RequireFromString("1.0"), sql.MustCreateDecimalType(2, 1)), expression.NewUnresolvedColumn("a")),
-							expression.NewMult(expression.NewLiteral(decimal.RequireFromString("2.0"), sql.MustCreateDecimalType(2, 1)), expression.NewUnresolvedColumn("b")),
+							expression.NewMult(expression.NewLiteral(decimal.RequireFromString("1.0"), types.MustCreateDecimalType(2, 1)), expression.NewUnresolvedColumn("a")),
+							expression.NewMult(expression.NewLiteral(decimal.RequireFromString("2.0"), types.MustCreateDecimalType(2, 1)), expression.NewUnresolvedColumn("b")),
 						),
 					),
 				},
@@ -5259,23 +5259,23 @@ func TestParseColumnTypeString(t *testing.T) {
 		},
 		{
 			"DECIMAL",
-			sql.MustCreateColumnDecimalType(10, 0),
+			types.MustCreateColumnDecimalType(10, 0),
 		},
 		{
 			"DECIMAL(22)",
-			sql.MustCreateColumnDecimalType(22, 0),
+			types.MustCreateColumnDecimalType(22, 0),
 		},
 		{
 			"DECIMAL(55, 13)",
-			sql.MustCreateColumnDecimalType(55, 13),
+			types.MustCreateColumnDecimalType(55, 13),
 		},
 		{
 			"DEC(34, 2)",
-			sql.MustCreateColumnDecimalType(34, 2),
+			types.MustCreateColumnDecimalType(34, 2),
 		},
 		{
 			"FIXED(4, 4)",
-			sql.MustCreateColumnDecimalType(4, 4),
+			types.MustCreateColumnDecimalType(4, 4),
 		},
 		{
 			"BIT(31)",
diff --git a/sql/plan/values_derived_table.go b/sql/plan/values_derived_table.go
@@ -203,7 +203,7 @@ func getMostPermissiveType(s *sql.Column, e sql.Expression) sql.Type {
 		if et.Scale() > frac {
 			frac = et.Scale()
 		}
-		return sql.MustCreateDecimalType(whole+frac, frac)
+		return types.MustCreateDecimalType(whole+frac, frac)
 	} else if types.IsDecimal(e.Type()) {
 		return e.Type()
 	}
diff --git a/sql/type.go b/sql/type.go
@@ -151,6 +151,32 @@ type EnumType interface {
 	Values() []string
 }
 
+// DecimalType represents the DECIMAL type.
+// https://dev.mysql.com/doc/refman/8.0/en/fixed-point-types.html
+// The type of the returned value is decimal.Decimal.
+type DecimalType interface {
+	Type
+	// ConvertToNullDecimal converts the given value to a decimal.NullDecimal if it has a compatible type. It is worth
+	// noting that Convert() returns a nil value for nil inputs, and also returns decimal.Decimal rather than
+	// decimal.NullDecimal.
+	ConvertToNullDecimal(v interface{}) (decimal.NullDecimal, error)
+	//ConvertNoBoundsCheck normalizes an interface{} to a decimal type without performing expensive bound checks
+	ConvertNoBoundsCheck(v interface{}) (decimal.Decimal, error)
+	// BoundsCheck rounds and validates a decimal
+	BoundsCheck(v decimal.Decimal) (decimal.Decimal, error)
+	// ExclusiveUpperBound returns the exclusive upper bound for this Decimal.
+	// For example, DECIMAL(5,2) would return 1000, as 999.99 is the max represented.
+	ExclusiveUpperBound() decimal.Decimal
+	// MaximumScale returns the maximum scale allowed for the current precision.
+	MaximumScale() uint8
+	// Precision returns the base-10 precision of the type, which is the total number of digits. For example, a
+	// precision of 3 means that 999, 99.9, 9.99, and .999 are all valid maximums (depending on the scale).
+	Precision() uint8
+	// Scale returns the scale, or number of digits after the decimal, that may be held.
+	// This will always be less than or equal to the precision.
+	Scale() uint8
+}
+
 type Type2 interface {
 	Type
 
@@ -248,15 +274,15 @@ func ApproximateTypeFromValue(val interface{}) Type {
 		if len(str) > 66 {
 			return types.Float64
 		} else if dotIdx == -1 {
-			typ, err := CreateDecimalType(uint8(len(str)), 0)
+			typ, err := types.CreateDecimalType(uint8(len(str)), 0)
 			if err != nil {
 				return types.Float64
 			}
 			return typ
 		} else {
 			precision := uint8(len(str) - 1)
 			scale := uint8(len(str) - dotIdx - 1)
-			typ, err := CreateDecimalType(precision, scale)
+			typ, err := types.CreateDecimalType(precision, scale)
 			if err != nil {
 				return types.Float64
 			}
@@ -338,7 +364,7 @@ func ColumnTypeToType(ct *sqlparser.ColumnType) (Type, error) {
 				return nil, err
 			}
 		}
-		return CreateColumnDecimalType(uint8(precision), uint8(scale))
+		return types.CreateColumnDecimalType(uint8(precision), uint8(scale))
 	case "bit":
 		length := int64(1)
 		if ct.Length != nil {
diff --git a/sql/types/decimal.go b/sql/types/decimal.go
diff --git a/sql/types/decimal_test.go b/sql/types/decimal_test.go
diff --git a/sql/types/typecheck.go b/sql/types/typecheck.go

Original file line number	Diff line number	Diff line change
`@@ -1691,7 +1691,7 @@ var ScriptTests = []ScriptTest{`
`1691`	`1691`	`},`
`1692`	`1692`	`{`
`1693`	`1693`	`Query: "INSERT INTO small_test VALUES (12.1);",`
`1694`		`- ExpectedErr: sql.ErrConvertToDecimalLimit,`
	`1694`	`+ ExpectedErr: types.ErrConvertToDecimalLimit,`
`1695`	`1695`	`},`
`1696`	`1696`	`},`
`1697`	`1697`	`},`
Original file line number	Diff line number	Diff line change
`@@ -226,11 +226,11 @@ func bindingsToExprs(bindings map[string]*query.BindVariable) (map[string]sql.Ex`
`226`	`226`	`}`
`227`	`227`	`res[k] = expression.NewLiteral(c, t)`
`228`	`228`	`case v.Type() == sqltypes.Decimal:`
`229`		`- v, err := sql.InternalDecimalType.Convert(string(v.ToBytes()))`
	`229`	`+ v, err := types.InternalDecimalType.Convert(string(v.ToBytes()))`
`230`	`230`	`if err != nil {`
`231`	`231`	`return nil, err`
`232`	`232`	`}`
`233`		`- res[k] = expression.NewLiteral(v, sql.InternalDecimalType)`
	`233`	`+ res[k] = expression.NewLiteral(v, types.InternalDecimalType)`
`234`	`234`	`case v.Type() == sqltypes.Bit:`
`235`	`235`	`t := sql.MustCreateBitType(sql.BitTypeMaxBits)`
`236`	`236`	`v, err := t.Convert(v.ToBytes())`
Original file line number	Diff line number	Diff line change
`@@ -52,7 +52,7 @@ var (`
`52`	`52`	`reflect.TypeOf(string("")): types.LongText,`
`53`	`53`	`reflect.TypeOf([]byte{}): types.LongBlob,`
`54`	`54`	`reflect.TypeOf(time.Time{}): types.Datetime,`
`55`		`- reflect.TypeOf(decimal.Decimal{}): sql.InternalDecimalType,`
	`55`	`+ reflect.TypeOf(decimal.Decimal{}): types.InternalDecimalType,`
`56`	`56`	`}`
`57`	`57`	`// externalStoredProcedurePointerTypes maps a pointer type to a sql.Type for external stored procedures.`
`58`	`58`	`externalStoredProcedurePointerTypes = map[reflect.Type]sql.Type{`
`@@ -72,7 +72,7 @@ var (`
`72`	`72`	`reflect.TypeOf((*string)(nil)): types.LongText,`
`73`	`73`	`reflect.TypeOf((*[]byte)(nil)): types.LongBlob,`
`74`	`74`	`reflect.TypeOf((*time.Time)(nil)): types.Datetime,`
`75`		`- reflect.TypeOf((*decimal.Decimal)(nil)): sql.InternalDecimalType,`
	`75`	`+ reflect.TypeOf((*decimal.Decimal)(nil)): types.InternalDecimalType,`
`76`	`76`	`}`
`77`	`77`	`)`
`78`	`78`
Original file line number	Diff line number	Diff line change
`@@ -69,11 +69,11 @@ func combinedCaseBranchType(left, right sql.Type) sql.Type {`
`69`	`69`	`return types.Float32`
`70`	`70`	`}`
`71`	`71`	`if types.IsDecimal(left) \|\| types.IsDecimal(right) {`
`72`		`- return sql.MustCreateDecimalType(65, 10)`
	`72`	`+ return types.MustCreateDecimalType(65, 10)`
`73`	`73`	`}`
`74`	`74`	`if left == types.Uint64 && types.IsSigned(right) \|\|`
`75`	`75`	`right == types.Uint64 && types.IsSigned(left) {`
`76`		`- return sql.MustCreateDecimalType(65, 10)`
	`76`	`+ return types.MustCreateDecimalType(65, 10)`
`77`	`77`	`}`
`78`	`78`	`if !types.IsSigned(left) && !types.IsSigned(right) {`
`79`	`79`	`return types.Uint64`
Original file line number	Diff line number	Diff line change
`@@ -161,7 +161,7 @@ func TestCaseType(t *testing.T) {`
`161`	`161`	`}`
`162`	`162`	`}`
`163`	`163`
`164`		`- decimalType := sql.MustCreateDecimalType(65, 10)`
	`164`	`+ decimalType := types.MustCreateDecimalType(65, 10)`
`165`	`165`
`166`	`166`	`testCases := []struct {`
`167`	`167`	`name string`
Original file line number	Diff line number	Diff line change
`@@ -150,8 +150,8 @@ func (d Div) Eval(ctx sql.Context, row sql.Row) (interface{}, error) {`
`150`	`150`	`if isOutermostDiv(d, 0, d.divScale) {`
`151`	`151`	`if res, ok := result.(decimal.Decimal); ok {`
`152`	`152`	`finalScale := d.divScale*int32(divPrecisionIncrement) + d.leftmostScale`
`153`		`- if finalScale > sql.DecimalTypeMaxScale {`
`154`		`- finalScale = sql.DecimalTypeMaxScale`
	`153`	`+ if finalScale > types.DecimalTypeMaxScale {`
	`154`	`+ finalScale = types.DecimalTypeMaxScale`
`155`	`155`	`}`
`156`	`156`	`if isOutermostArithmeticOp(d, 0, d.ops) {`
`157`	`157`	`return res.Round(finalScale), nil`
`@@ -315,9 +315,9 @@ func floatOrDecimalType(e sql.Expression) sql.Type {`
`315`	`315`	`}`
`316`	`316`
`317`	`317`	`// defType is defined by evaluating all number literals available`
`318`		`- defType, derr := sql.CreateDecimalType(maxWhole+maxFrac, maxFrac)`
	`318`	`+ defType, derr := types.CreateDecimalType(maxWhole+maxFrac, maxFrac)`
`319`	`319`	`if derr != nil {`
`320`		`- return sql.MustCreateDecimalType(65, 10)`
	`320`	`+ return types.MustCreateDecimalType(65, 10)`
`321`	`321`	`}`
`322`	`322`
`323`	`323`	`return defType`
`@@ -334,7 +334,7 @@ func convertToDecimalValue(val interface{}, isTimeType bool) interface{} {`
`334`	`334`
`335`	`335`	`if _, ok := val.(decimal.Decimal); !ok {`
`336`	`336`	`p, s := GetPrecisionAndScale(val)`
`337`		`- dtyp, err := sql.CreateDecimalType(p, s)`
	`337`	`+ dtyp, err := types.CreateDecimalType(p, s)`
`338`	`338`	`if err != nil {`
`339`	`339`	`val = decimal.Zero`
`340`	`340`	`}`
`@@ -605,7 +605,7 @@ func (i *IntDiv) Type() sql.Type {`
`605`	`605`	`}`
`606`	`606`
`607`	`607`	`// using max precision which is 65.`
`608`		`- defType := sql.MustCreateDecimalType(65, 0)`
	`608`	`+ defType := types.MustCreateDecimalType(65, 0)`
`609`	`609`	`return defType`
`610`	`610`	`}`
`611`	`611`