decimal: read numeric text the way MySQL does

go/mysql/decimal/decimal_test.go

@@ -92,6 +92,12 @@ var testTableScientificNotation = map[string]string{
 	"123.456e0":  "123.456",
 	"123.456e2":  "12345.6",
 	"123.456e10": "1234560000000",
+	// MySQL accepts a written plus on the exponent.
+	"1e+9":       "1000000000",
+	"1E+9":       "1000000000",
+	"245E+3":     "245000",
+	"123.456e+2": "12345.6",
+	"0e+5":       "0",
 }
 
 func init() {
@@ -192,6 +198,52 @@ func TestNewFromString(t *testing.T) {
 	}
 }
 
+// TestNewFromStringLeadingPlus covers a sign the negating entries in
+// testTableScientificNotation cannot: MySQL reads a leading plus as the number
+// it introduces, so CAST('+1' AS DECIMAL) is 1.
+func TestNewFromStringLeadingPlus(t *testing.T) {
+	for in, want := range map[string]string{
+		"+1":          "1",
+		"+1.5":        "1.5",
+		"+0":          "0",
+		"+1e9":        "1000000000",
+		"+1e+9":       "1000000000",
+		"+123.456e-2": "1.23456",
+		// The number starts after any leading whitespace, and so does the sign.
+		" +1":     "1",
+		" -1":     "-1",
+		"  +1.5":  "1.5",
+		" -1e+5":  "-100000",
+		"\t-2":    "-2",
+		" 1.5e+3": "1500",
+	} {
+		t.Run(in, func(t *testing.T) {
+			d, err := NewFromString(in)
+			require.NoError(t, err)
+			require.Equal(t, want, d.String())
+		})
+	}
+}
+
+// TestNewFromStringZeroExponent pins the formatting of a zero written with a
+// positive exponent. String trims the padding away, but FormatMySQL keeps the
+// scale it is asked for, so a stale exponent surfaces as leading zeros.
+func TestNewFromStringZeroExponent(t *testing.T) {
+	for _, in := range []string{"0e5", "-0e5", "+0e5", "0E+5", "0e2", "0"} {
+		t.Run(in, func(t *testing.T) {
+			d, err := NewFromString(in)
+			require.NoError(t, err)
+			require.Equal(t, "0", d.String())
+			require.Equal(t, "0.000000", string(d.FormatMySQL(6)))
+		})
+	}
+
+	// A zero written to a scale keeps it: only a positive exponent is dropped.
+	d, err := NewFromString("0.00")
+	require.NoError(t, err)
+	require.Equal(t, int32(-2), d.Exponent())
+}
+
 func TestFloat64(t *testing.T) {
 	t.Skipf("Float64 does not check for exact")
 

go/mysql/decimal/scan.go

@@ -180,13 +180,18 @@ func NewFromString(s string) (d Decimal, err error) {
 		}
 		i++
 	}
+
+	// The number starts after the leading whitespace, so that is where a sign
+	// is allowed and where the mantissa is read from.
+	start := i
 next:
 	for i < maxLen {
 		switch {
-		case s[i] == '-':
-			// Negative sign is allowed at the start and at the start
-			// of the exponent.
-			if i != 0 && expPos == -1 && i != expPos+1 {
+		case s[i] == '-' || s[i] == '+':
+			// A sign is allowed at the start of the number and at the start of
+			// the exponent, nowhere else. With no exponent seen yet expPos is
+			// -1, so the second test collapses into the first.
+			if i != start && i != expPos+1 {
 				break next
 			}
 		case s[i] >= '0' && s[i] <= '9':
@@ -215,17 +220,21 @@ next:
 	var si string
 	switch {
 	case dotPos == -1 && expPos == -1:
-		si = s[:i]
+		si = s[start:i]
 	case expPos == -1:
-		si = s[:dotPos] + s[dotPos+1:i]
+		si = s[start:dotPos] + s[dotPos+1:i]
 		exp -= int64(i - dotPos - 1)
 	case dotPos == -1:
-		si = s[:expPos]
+		si = s[start:expPos]
 	default:
-		si = s[:dotPos] + s[dotPos+1:expPos]
+		si = s[start:dotPos] + s[dotPos+1:expPos]
 		exp -= int64(expPos - dotPos - 1)
 	}
 
+	// fastparse reads a leading minus but not a leading plus, which the scanner
+	// above accepts because MySQL does.
+	si = strings.TrimPrefix(si, "+")
+
 	if len(si) <= 18 {
 		var v int64
 		v, err = fastparse.ParseInt64(si, 10)
@@ -237,7 +246,7 @@ next:
 
 	var expOverflow bool
 	if expPos != -1 {
-		e, _ := fastparse.ParseInt64(s[expPos+1:i], 10)
+		e, _ := fastparse.ParseInt64(strings.TrimPrefix(s[expPos+1:i], "+"), 10)
 		switch {
 		case e > ExponentLimit:
 			e = ExponentLimit
@@ -249,6 +258,13 @@ next:
 		exp += e
 	}
 
+	// Scaling zero by a positive power of ten leaves zero, but keeping the
+	// exponent renders it as that many leading zeros: '0e5' would format as
+	// 000000 where MySQL prints 0. A negative exponent is left alone, since it
+	// is the scale a zero is written to.
+	if exp > 0 && d.value.Sign() == 0 {
+		exp = 0
+	}
 	d.exp = int32(exp)
 
 	for i < maxLen {

go/mysql/json/parser_test.go

@@ -85,6 +85,18 @@ func TestParseRawNumber(t *testing.T) {
 func TestParseNumberTooBigForDouble(t *testing.T) {
 	tooManyDigits := "1" + strings.Repeat("0", 309)
 
+	// The subnormal 2.2250738585072011e-308, written out to nearly eight
+	// hundred digits of fraction.
+	longFraction := "2.22507385850720113605740979670913197593481954635164564802342610972482222202107694551652952390813508" +
+		"7914149158913039621106870086438694594645527657207407820621743379988141063267329253552286881372149012" +
+		"9811224514518898490572223072852551331557550159143974763979834118019993239625482890171070818506906306" +
+		"6665599493827577257201576306269066333264756530000924588831643303777979186961204949739037782970490505" +
+		"1080609940730262937128958950003583799967207254304360284078895771796150945516748243471030702609144621" +
+		"5722898802581825451803257070188608721131280795122334262883686223215037756666225039825343359745688844" +
+		"2390026549819838548794829220689472168983109969836584681402285424333066033985088644580400103493397042" +
+		"7567186443383770486037861622771738545623065874679014086723327636718751234567890123456789012345678901" +
+		"e-308"
+
 	t.Run("accepted", func(t *testing.T) {
 		for _, doc := range []string{
 			"1e308",
@@ -93,6 +105,7 @@ func TestParseNumberTooBigForDouble(t *testing.T) {
 			"-1.7976931348623157e308",
 			"99999999999999999999999999999999999999999",
 			"1" + strings.Repeat("0", 307),
+			"1" + strings.Repeat("0", 308),
 			// Underflow keeps the document valid and reads as zero.
 			"1e-400",
 			"1e-1000",
@@ -121,7 +134,14 @@ func TestParseNumberTooBigForDouble(t *testing.T) {
 			"0.00e310",
 			"0.1e309",
 			"0.01e310",
+			// The largest double itself, written so that its exponent stands
+			// past the bound until the fraction buys the places back.
+			"0.017976931348623157e+310",
 			"0." + strings.Repeat("0", 400) + "1e700",
+			// A fraction contributes seventeen significant digits; the
+			// hundreds behind these move neither the value nor the decimal
+			// point, however many there are.
+			longFraction,
 		} {
 			t.Run(startEndString(doc), func(t *testing.T) {
 				var p Parser
@@ -155,6 +175,7 @@ func TestParseNumberTooBigForDouble(t *testing.T) {
 			// Within the written bound, but too big once converted.
 			"10e308",
 			"1" + strings.Repeat("0", 30) + "e279",
+			"0.017976931348623159e+310",
 			// More digits than a double has room for. The digits are read before
 			// the exponent is applied, so a negative exponent does not buy the
 			// room back however far it moves the decimal point afterwards.
@@ -203,6 +224,31 @@ func TestParseNumberTooBigForDouble(t *testing.T) {
 		}
 	})
 
+	// The int a negative exponent accumulates into stops taking digits once
+	// another could overflow it. Everything written by then already sits far
+	// below the smallest double, so however much further the spelling runs,
+	// these stay valid and read as zero. MySQL 8.0.46 reads each of them the
+	// same way.
+	t.Run("a negative exponent around the stop of the int it accumulates into", func(t *testing.T) {
+		for _, doc := range []string{
+			"1e-214748363",
+			"1e-214748364",
+			"1e-21474836311",
+			"1e-00011111111111",
+			"-1e-00011111111111",
+		} {
+			t.Run(doc, func(t *testing.T) {
+				var p Parser
+				v, err := p.Parse(doc)
+				require.NoError(t, err)
+
+				f, ok := v.Float64()
+				require.True(t, ok)
+				require.Zero(t, f)
+			})
+		}
+	})
+
 	// The significand accumulates one digit at a time, and each step rounds
 	// the multiplication and the addition separately, the way MySQL's builds
 	// run the loop. Fusing the two into one rounding — which the Go compiler
@@ -288,10 +334,13 @@ func TestParseNumberGrammar(t *testing.T) {
 			"007", "-003", "01", "00", "00.5", "01.5", "[007]",
 			// A decimal point missing a digit on one side.
 			".2", "-.2", "12.", "-12.", "1.e5", `{"a": .2}`, "[12.]",
+			// An exponent missing its digits.
+			"1e", "1e_", "1e+", "1e-", "[1e]",
 			// A written plus.
 			"+1", "+1.5", "+0", "[+1]",
 			// Not a number at all.
 			"nan", "NaN", "NAN", "[nan]", `{"a": nan}`, "-nan", ".", "-",
+			"inf", "-inf", "Infinity", "[inf]",
 		} {
 			t.Run(doc, func(t *testing.T) {
 				var p Parser
@@ -302,6 +351,37 @@ func TestParseNumberGrammar(t *testing.T) {
 	})
 }
 
+// TestParseNumberIntegerBoundaries walks the spellings on either side of each
+// integer width a JSON number can outgrow — int32, uint32, int64, uint64 —
+// until only a double can hold it. Every one of them is a number to MySQL,
+// exact while an int64 or a uint64 still holds it and approximate once only a
+// double does.
+func TestParseNumberIntegerBoundaries(t *testing.T) {
+	for _, tc := range []struct {
+		doc string
+		n   NumberType
+	}{
+		{"-2147483648", NumberTypeSigned},
+		{"-2147483649", NumberTypeSigned},
+		{"4294967295", NumberTypeSigned},
+		{"4294967296", NumberTypeSigned},
+		{"9223372036854775807", NumberTypeSigned},
+		{"9223372036854775808", NumberTypeUnsigned},
+		{"-9223372036854775808", NumberTypeSigned},
+		{"-9223372036854775809", NumberTypeFloat},
+		{"18446744073709551615", NumberTypeUnsigned},
+		{"18446744073709551616", NumberTypeFloat},
+	} {
+		t.Run(tc.doc, func(t *testing.T) {
+			var p Parser
+			v, err := p.Parse(tc.doc)
+			require.NoError(t, err)
+			require.Equal(t, TypeNumber, v.Type())
+			require.Equal(t, tc.n, v.NumberType())
+		})
+	}
+}
+
 // TestParseErrorAbbreviatesTheDocument covers how much of a rejected document
 // its error names. Nothing bounds how long a document may be, and Parse copies
 // the message it wraps, so naming the text in full hands a client its own

go/vt/vtgate/evalengine/compiler_test.go

@@ -923,6 +923,46 @@ func TestCompilerSingle(t *testing.T) {
 	}
 }
 
+// TestCastInvalidJSON pins that text MySQL refuses as a JSON document is
+// refused by both evaluation paths. The differential suite cannot pin this
+// direction: its comparison excuses a MySQL "Invalid JSON text" error when
+// the local evaluation succeeds, so a cast that wrongly started accepting one
+// of these spellings would stay green there.
+func TestCastInvalidJSON(t *testing.T) {
+	testCases := []struct {
+		expression string
+		wantErr    string
+	}{
+		{`CAST('+1' AS JSON)`, "invalid number"},
+		{`CAST(' +1' AS JSON)`, "invalid number"},
+		{`CAST('+1.5' AS JSON)`, "invalid number"},
+		{`CAST('1e309' AS JSON)`, "number too big to be stored in double"},
+	}
+
+	venv := vtenv.NewTestEnv()
+	for _, tc := range testCases {
+		t.Run(tc.expression, func(t *testing.T) {
+			expr, err := venv.Parser().ParseExpr(tc.expression)
+			require.NoError(t, err)
+
+			cfg := &evalengine.Config{
+				Collation:         collations.CollationUtf8mb4ID,
+				Environment:       venv,
+				NoConstantFolding: true,
+			}
+			converted, err := evalengine.Translate(expr, cfg)
+			require.NoError(t, err)
+
+			env := evalengine.EmptyExpressionEnv(venv)
+			_, err = env.EvaluateAST(converted)
+			require.ErrorContains(t, err, tc.wantErr)
+
+			_, err = env.Evaluate(converted)
+			require.ErrorContains(t, err, tc.wantErr)
+		})
+	}
+}
+
 func TestBindVarLiteral(t *testing.T) {
 	testCases := []struct {
 		expression string

go/vt/vtgate/evalengine/testcases/cases.go

@@ -46,6 +46,7 @@ var Cases = []TestCase{
 	{Run: LargeDecimals},
 	{Run: LargeIntegers},
 	{Run: DecimalClamping},
+	{Run: SignedExponents},
 	{Run: BitwiseOperatorsUnary},
 	{Run: BitwiseOperators},
 	{Run: WeightString},
@@ -914,6 +915,28 @@ func DecimalClamping(yield Query) {
 	}
 }
 
+// SignedExponents covers numeric text carrying a written sign, on the number
+// itself and on its exponent. MySQL reads both, so a cast or a JSON comparison
+// over one has to land on the same value.
+func SignedExponents(yield Query) {
+	mantissas := []string{"1", "+1", "-1", "1.5", "+1.5", "-1.5", "0", "+0", "-0"}
+	exponents := []string{"", "e5", "e+5", "E+5", "e-5", "E-5", "e+0", "e-0"}
+
+	for _, mantissa := range mantissas {
+		for _, exponent := range exponents {
+			literal := "'" + mantissa + exponent + "'"
+			yield(fmt.Sprintf("CAST(%s AS DECIMAL(20, 6))", literal), nil, false)
+			yield(fmt.Sprintf("CAST(%s AS DOUBLE)", literal), nil, false)
+			yield(literal+" + 0", nil, false)
+
+			// JSON comparison reads the number through a decimal too, so it is
+			// worth exercising directly. A leading plus is not a JSON number,
+			// so those spellings pin the cast being rejected rather than a value.
+			yield(fmt.Sprintf("CAST(%s AS JSON) = CAST(%s AS JSON)", literal, literal), nil, false)
+		}
+	}
+}
+
 func BitwiseOperatorsUnary(yield Query) {
 	for _, op := range []string{"~", "BIT_COUNT"} {
 		for _, rhs := range inputBitwise {