Do not allow inserting NaN and Inf values into numeric type columns

angelamayxie · angelamayxie · commit 4c093bb10dc4 · 2025-10-15T12:20:05.000-07:00
diff --git a/memory/table_test.go b/memory/table_test.go
@@ -15,8 +15,10 @@
 package memory_test
 
 import (
+	"context"
 	"fmt"
 	"io"
+	"math"
 	"testing"
 
 	"github.com/stretchr/testify/require"
@@ -62,6 +64,73 @@ func TestTableString(t *testing.T) {
 	require.Equal("foo", table.String())
 }
 
+func TestTableInsert(t *testing.T) {
+	testCases := []struct {
+		name    string
+		colType sql.Type
+		value   interface{}
+		err     bool
+	}{
+		{
+			name:    "inserting NaN into float results in error",
+			colType: types.Float64,
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting NaN into int results in error",
+			colType: types.Int64,
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting NaN into Decimal results in error",
+			colType: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, types.DecimalTypeMaxScale),
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into float results in error",
+			colType: types.Float64,
+			value:   math.Inf(1),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into int results in error",
+			colType: types.Int64,
+			value:   math.Inf(1),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into Decimal results in error",
+			colType: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, types.DecimalTypeMaxScale),
+			value:   math.Inf(1),
+			err:     true,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			db := memory.NewDatabase("db")
+
+			provider := memory.NewDBProvider(db)
+			session := memory.NewSession(sql.NewBaseSession(), provider)
+			ctx := sql.NewContext(context.Background(), sql.WithSession(session))
+
+			table := memory.NewTable(db, "test", sql.NewPrimaryKeySchema(sql.Schema{
+				{Name: "col1", Type: tc.colType, Nullable: false},
+			}), nil)
+
+			err := table.Insert(ctx, sql.NewRow(tc.value))
+			if tc.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}
+
 type indexKeyValue struct {
 	key   sql.Row
 	value *memory.IndexValue
diff --git a/sql/rowexec/insert.go b/sql/rowexec/insert.go
@@ -161,13 +161,12 @@ func (i *insertIter) Next(ctx *sql.Context) (returnRow sql.Row, returnErr error)
 					continue
 				} else {
 					// Fill in error with information
-					if types.ErrLengthBeyondLimit.Is(cErr) {
+					switch {
+					case types.ErrLengthBeyondLimit.Is(cErr):
 						cErr = types.ErrLengthBeyondLimit.New(row[idx], col.Name)
-					} else if sql.ErrNotMatchingSRID.Is(cErr) {
+					case sql.ErrNotMatchingSRID.Is(cErr):
 						cErr = sql.ErrNotMatchingSRIDWithColName.New(col.Name, cErr)
-					} else if types.ErrConvertingToEnum.Is(cErr) {
-						cErr = types.ErrDataTruncatedForColumnAtRow.New(col.Name, i.rowNumber)
-					} else if sql.ErrInvalidSetValue.Is(cErr) || sql.ErrConvertingToSet.Is(cErr) {
+					case types.ErrConvertingToEnum.Is(cErr), sql.ErrInvalidSetValue.Is(cErr), sql.ErrConvertingToSet.Is(cErr):
 						cErr = types.ErrDataTruncatedForColumnAtRow.New(col.Name, i.rowNumber)
 					}
 					return nil, sql.NewWrappedInsertError(origRow, cErr)
diff --git a/sql/rowexec/insert_test.go b/sql/rowexec/insert_test.go
@@ -15,6 +15,7 @@
 package rowexec
 
 import (
+	"math"
 	"testing"
 	"time"
 
@@ -28,46 +29,88 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
-func TestInsertIgnoreConversions(t *testing.T) {
+func TestInsert(t *testing.T) {
 	testCases := []struct {
 		name      string
 		colType   sql.Type
 		value     interface{}
 		valueType sql.Type
 		expected  interface{}
+		warning   bool
+		ignore    bool
 		err       bool
 	}{
 		{
-			name:      "inserting a string into a integer defaults to a 0",
+			name:      "inserting a string into a integer defaults to a 0 (with ignore)",
 			colType:   types.Int64,
 			value:     "dadasd",
 			valueType: types.Text,
 			expected:  int64(0),
-			err:       true,
+			warning:   true,
+			ignore:    true,
 		},
 		{
-			name:      "string too long gets truncated",
+			name:      "string too long gets truncated (with ignore)",
 			colType:   types.MustCreateStringWithDefaults(sqltypes.VarChar, 2),
 			value:     "dadsa",
 			valueType: types.Text,
 			expected:  "da",
-			err:       true,
+			warning:   true,
+			ignore:    true,
 		},
 		{
-			name:      "inserting a string into a datetime results in 0 time",
+			name:      "inserting a string into a datetime results in 0 time (with ignore)",
 			colType:   types.Datetime,
 			value:     "dadasd",
 			valueType: types.Text,
 			expected:  time.Unix(-62167219200, 0).UTC(),
-			err:       true,
+			warning:   true,
+			ignore:    true,
 		},
 		{
-			name:      "inserting a negative into an unsigned int results in 0",
+			name:      "inserting a negative into an unsigned int results in 0 (with ignore)",
 			colType:   types.Uint64,
 			value:     int64(-1),
 			expected:  uint64(1<<64 - 1),
 			valueType: types.Uint64,
-			err:       true,
+			warning:   true,
+			ignore:    true,
+		},
+		{
+			name:    "inserting NaN into float results in error",
+			colType: types.Float64,
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting NaN into int results in error",
+			colType: types.Int64,
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting NaN into Decimal results in error",
+			colType: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, types.DecimalTypeMaxScale),
+			value:   math.NaN(),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into float results in error",
+			colType: types.Float64,
+			value:   math.Inf(1),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into int results in error",
+			colType: types.Int64,
+			value:   math.Inf(1),
+			err:     true,
+		},
+		{
+			name:    "inserting Infinity into Decimal results in error",
+			colType: types.MustCreateDecimalType(types.DecimalTypeMaxPrecision, types.DecimalTypeMaxScale),
+			value:   math.Inf(1),
+			err:     true,
 		},
 	}
 
@@ -83,21 +126,25 @@ func TestInsertIgnoreConversions(t *testing.T) {
 
 			insertPlan := plan.NewInsertInto(sql.UnresolvedDatabase(""), plan.NewResolvedTable(table, nil, nil), plan.NewValues([][]sql.Expression{{
 				expression.NewLiteral(tc.value, tc.valueType),
-			}}), false, []string{"c1"}, []sql.Expression{}, true)
+			}}), false, []string{"c1"}, []sql.Expression{}, tc.ignore)
 
 			ri, err := DefaultBuilder.Build(ctx, insertPlan, nil)
 			require.NoError(t, err)
 
 			row, err := ri.Next(ctx)
-			require.NoError(t, err)
+			if tc.err {
+				require.Error(t, err)
+			} else {
+				require.NoError(t, err)
 
-			require.Equal(t, sql.Row{tc.expected}, row)
+				require.Equal(t, sql.Row{tc.expected}, row)
 
-			var warningCnt int
-			if tc.err {
-				warningCnt = 1
+				var warningCnt int
+				if tc.warning {
+					warningCnt = 1
+				}
+				require.Equal(t, ctx.WarningCount(), uint16(warningCnt))
 			}
-			require.Equal(t, ctx.WarningCount(), uint16(warningCnt))
 		})
 	}
 }
diff --git a/sql/types/decimal.go b/sql/types/decimal.go
@@ -17,6 +17,7 @@ package types
 import (
 	"context"
 	"fmt"
+	"math"
 	"math/big"
 	"reflect"
 	"strings"
@@ -203,6 +204,9 @@ func (t DecimalType_) ConvertToNullDecimal(v interface{}) (decimal.NullDecimal,
 	case float32:
 		return t.ConvertToNullDecimal(decimal.NewFromFloat32(value))
 	case float64:
+		if math.IsInf(value, 0) || math.IsNaN(value) {
+			return decimal.NullDecimal{}, ErrConvertingToDecimal.New(v)
+		}
 		return t.ConvertToNullDecimal(decimal.NewFromFloat(value))
 	case string:
 		var err error
diff --git a/sql/types/number.go b/sql/types/number.go
@@ -1093,6 +1093,9 @@ func convertToInt64(t NumberTypeImpl_, v any, round Round) (int64, sql.ConvertIn
 		if v < float64(math.MinInt64) {
 			return math.MinInt64, sql.OutOfRange, nil
 		}
+		if math.IsInf(v, 0) || math.IsNaN(v) {
+			return 0, sql.OutOfRange, sql.ErrInvalidValue.New(v, t.String())
+		}
 		return int64(math.Round(v)), sql.InRange, nil
 	case decimal.Decimal:
 		if v.GreaterThan(dec_int64_max) {
@@ -1291,6 +1294,9 @@ func convertToUint64(t NumberTypeImpl_, v any, round Round) (uint64, sql.Convert
 		if v < 0 {
 			return uint64(math.MaxUint64 - uint(-v-1)), sql.OutOfRange, nil
 		}
+		if math.IsInf(v, 0) || math.IsNaN(v) {
+			return 0, sql.OutOfRange, sql.ErrInvalidValue.New(v, t.String())
+		}
 		return uint64(math.Round(v)), sql.InRange, nil
 	case decimal.Decimal:
 		if v.GreaterThan(dec_uint64_max) {
@@ -1389,6 +1395,9 @@ func convertToFloat64(t NumberTypeImpl_, v interface{}) (float64, error) {
 	case float32:
 		return float64(v), nil
 	case float64:
+		if math.IsInf(v, 0) || math.IsNaN(v) {
+			return 0, sql.ErrInvalidValue.New(v, t.String())
+		}
 		return v, nil
 	case decimal.Decimal:
 		f, _ := v.Float64()
