add auto-increment overflow protection for all integer types

elianddb · elianddb · commit 10711e040ce9 · 2025-07-28T23:19:07.000Z
diff --git a/enginetest/queries/script_queries.go b/enginetest/queries/script_queries.go
@@ -10644,7 +10644,6 @@ where
 		},
 		Assertions: []ScriptTestAssertion{
 			{
-				Skip:        true,
 				Query:       "insert into tinyint_tbl values (999)",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10668,7 +10667,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into smallint_tbl values (99999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10692,12 +10690,10 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into mediumint_tbl values (99999999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
 			{
-				Skip:  true,
 				Query: "insert into mediumint_tbl values (8388607);",
 				Expected: []sql.Row{
 					{types.OkResult{
@@ -10707,7 +10703,6 @@ where
 				},
 			},
 			{
-				Skip:  true,
 				Query: "show create table mediumint_tbl;",
 				Expected: []sql.Row{
 					{"mediumint_tbl", "CREATE TABLE `mediumint_tbl` (\n" +
@@ -10718,7 +10713,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into int_tbl values (99999999999)",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10742,7 +10736,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into bigint_tbl values (99999999999999999999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10779,7 +10772,6 @@ where
 		},
 		Assertions: []ScriptTestAssertion{
 			{
-				Skip:        true,
 				Query:       "insert into tinyint_tbl values (999)",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10803,7 +10795,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into smallint_tbl values (99999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10827,7 +10818,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into mediumint_tbl values (999999999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10851,7 +10841,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into int_tbl values (99999999999)",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
@@ -10875,7 +10864,6 @@ where
 			},
 
 			{
-				Skip:        true,
 				Query:       "insert into bigint_tbl values (999999999999999999999);",
 				ExpectedErr: sql.ErrValueOutOfRange,
 			},
diff --git a/memory/table.go b/memory/table.go
@@ -1150,6 +1150,7 @@ func (t *Table) PeekNextAutoIncrementValue(ctx *sql.Context) (uint64, error) {
 // GetNextAutoIncrementValue gets the next auto increment value for the memory table the increment.
 func (t *Table) GetNextAutoIncrementValue(ctx *sql.Context, insertVal interface{}) (uint64, error) {
 	data := t.sessionTableData(ctx)
+	
 
 	cmp, err := types.Uint64.Compare(ctx, insertVal, data.autoIncVal)
 	if err != nil {
diff --git a/memory/table_editor.go b/memory/table_editor.go
@@ -16,6 +16,7 @@ package memory
 
 import (
 	"fmt"
+	"math"
 	"reflect"
 	"strings"
 
@@ -186,26 +187,37 @@ func (t *tableEditor) Insert(ctx *sql.Context, row sql.Row) error {
 			return err
 		}
 		if cmp > 0 {
+			// Only update auto-increment if the value is valid for the column type
+			if _, inRange, err := autoCol.Type.Convert(ctx, row[idx]); err != nil || inRange != sql.InRange {
+				return nil // Don't update auto-increment for invalid values
+			}
 			v, _, err := types.Uint64.Convert(ctx, row[idx])
 			if err != nil {
 				return err
 			}
-			t.ea.TableData().autoIncVal = v.(uint64)
-			nextVal := v.(uint64) + 1
-			if _, inRange, err := autoCol.Type.Convert(ctx, nextVal); err == nil && inRange == sql.InRange {
-				t.ea.TableData().autoIncVal = nextVal
-			}
+			currentVal := v.(uint64)
+			t.ea.TableData().autoIncVal = currentVal
+			t.incrementAutoIncrementValue(ctx, autoCol, currentVal)
 		} else if cmp == 0 {
-			nextVal := t.ea.TableData().autoIncVal + 1
-			if _, inRange, err := autoCol.Type.Convert(ctx, nextVal); err == nil && inRange == sql.InRange {
-				t.ea.TableData().autoIncVal = nextVal
-			}
+			currentVal := t.ea.TableData().autoIncVal
+			t.incrementAutoIncrementValue(ctx, autoCol, currentVal)
 		}
 	}
 
 	return nil
 }
 
+// incrementAutoIncrementValue increments the auto-increment value if it won't cause overflow or exceed type bounds
+func (t *tableEditor) incrementAutoIncrementValue(ctx *sql.Context, autoCol *sql.Column, currentVal uint64) {
+	if currentVal == math.MaxUint64 {
+		return // Can't increment further
+	}
+	nextVal := currentVal + 1
+	if _, inRange, err := autoCol.Type.Convert(ctx, nextVal); err == nil && inRange == sql.InRange {
+		t.ea.TableData().autoIncVal = nextVal
+	}
+}
+
 // Delete the given row from the table.
 func (t *tableEditor) Delete(ctx *sql.Context, row sql.Row) error {
 	if err := checkRow(ctx, t.editedTable.Schema(), row); err != nil {
diff --git a/sql/rowexec/insert.go b/sql/rowexec/insert.go
@@ -120,7 +120,7 @@ func (i *insertIter) Next(ctx *sql.Context) (returnRow sql.Row, returnErr error)
 			ctxWithValues = context.WithValue(ctxWithValues, types.RowNumberKey, i.rowNumber)
 			ctxWithColumnInfo := ctx.WithContext(ctxWithValues)
 			converted, inRange, cErr := col.Type.Convert(ctxWithColumnInfo, row[idx])
-			if cErr == nil && !inRange {
+			if cErr == nil && inRange == sql.OutOfRange {
 				cErr = sql.ErrValueOutOfRange.New(row[idx], col.Type)
 			}
 			if cErr != nil {
diff --git a/sql/rowexec/insert_test.go b/sql/rowexec/insert_test.go
@@ -65,7 +65,7 @@ func TestInsertIgnoreConversions(t *testing.T) {
 			name:      "inserting a negative into an unsigned int results in 0",
 			colType:   types.Uint64,
 			value:     int64(-1),
-			expected:  uint64(1<<64 - 1),
+			expected:  uint64(0),
 			valueType: types.Uint64,
 			err:       true,
 		},
diff --git a/sql/rowexec/update_test.go b/sql/rowexec/update_test.go
@@ -61,7 +61,7 @@ func TestUpdateIgnoreConversions(t *testing.T) {
 			name:      "inserting a negative into an unsigned int results in 0",
 			colType:   types.Uint64,
 			value:     int64(-1),
-			expected:  uint64(1<<64 - 1),
+			expected:  uint64(0),
 			valueType: types.Uint64,
 		},
 	}
diff --git a/sql/types/number.go b/sql/types/number.go
@@ -260,41 +260,80 @@ func (t NumberTypeImpl_) Convert(ctx context.Context, v interface{}) (interface{
 		}
 	}
 
+	// Check if we're in strict mode for error handling
+	strictMode := false
+	if sqlCtx, ok := ctx.(*sql.Context); ok {
+		strictMode = sql.ValidateStrictMode(sqlCtx)
+	}
+
+
 	switch t.baseType {
 	case sqltypes.Int8:
 		num, _, err := convertToInt64(t, v)
 		if err != nil {
 			return nil, sql.OutOfRange, err
 		}
 		if num > math.MaxInt8 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int8(math.MaxInt8), sql.OutOfRange, nil
 		} else if num < math.MinInt8 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int8(math.MinInt8), sql.OutOfRange, nil
 		}
 		return int8(num), sql.InRange, nil
 	case sqltypes.Uint8:
-		return convertToUint8(t, v)
+		val, inRange, err := convertToUint8(t, v)
+		if err != nil {
+			return nil, sql.OutOfRange, err
+		}
+		if inRange == sql.OutOfRange && strictMode {
+			return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+		}
+		return val, inRange, nil
 	case sqltypes.Int16:
 		num, _, err := convertToInt64(t, v)
 		if err != nil {
 			return nil, sql.OutOfRange, err
 		}
 		if num > math.MaxInt16 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int16(math.MaxInt16), sql.OutOfRange, nil
 		} else if num < math.MinInt16 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int16(math.MinInt16), sql.OutOfRange, nil
 		}
 		return int16(num), sql.InRange, nil
 	case sqltypes.Uint16:
-		return convertToUint16(t, v)
+		val, inRange, err := convertToUint16(t, v)
+		if err != nil {
+			return nil, sql.OutOfRange, err
+		}
+		if inRange == sql.OutOfRange && strictMode {
+			return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+		}
+		return val, inRange, nil
 	case sqltypes.Int24:
 		num, _, err := convertToInt64(t, v)
 		if err != nil {
 			return nil, sql.OutOfRange, err
 		}
 		if num > (1<<23 - 1) {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int32(1<<23 - 1), sql.OutOfRange, nil
 		} else if num < (-1 << 23) {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int32(-1 << 23), sql.OutOfRange, nil
 		}
 		return int32(num), sql.InRange, nil
@@ -304,8 +343,14 @@ func (t NumberTypeImpl_) Convert(ctx context.Context, v interface{}) (interface{
 			return nil, sql.OutOfRange, err
 		}
 		if num >= (1 << 24) {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return uint32(1<<24 - 1), sql.OutOfRange, nil
 		} else if num < 0 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return uint32(1<<24 - int32(-num)), sql.OutOfRange, nil
 		}
 		return uint32(num), sql.InRange, nil
@@ -315,17 +360,44 @@ func (t NumberTypeImpl_) Convert(ctx context.Context, v interface{}) (interface{
 			return nil, sql.OutOfRange, err
 		}
 		if num > math.MaxInt32 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int32(math.MaxInt32), sql.OutOfRange, nil
 		} else if num < math.MinInt32 {
+			if strictMode {
+				return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+			}
 			return int32(math.MinInt32), sql.OutOfRange, nil
 		}
 		return int32(num), sql.InRange, nil
 	case sqltypes.Uint32:
-		return convertToUint32(t, v)
+		val, inRange, err := convertToUint32(t, v)
+		if err != nil {
+			return nil, sql.OutOfRange, err
+		}
+		if inRange == sql.OutOfRange && strictMode {
+			return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+		}
+		return val, inRange, nil
 	case sqltypes.Int64:
-		return convertToInt64(t, v)
+		val, inRange, err := convertToInt64(t, v)
+		if err != nil {
+			return nil, sql.OutOfRange, err
+		}
+		if inRange == sql.OutOfRange && strictMode {
+			return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+		}
+		return val, inRange, nil
 	case sqltypes.Uint64:
-		return convertToUint64(t, v)
+		val, inRange, err := convertToUint64(t, v)
+		if err != nil {
+			return nil, sql.OutOfRange, err
+		}
+		if inRange == sql.OutOfRange && strictMode {
+			return nil, sql.OutOfRange, sql.ErrValueOutOfRange.New(v, t.String())
+		}
+		return val, inRange, nil
 	case sqltypes.Float32:
 		num, err := convertToFloat64(t, v)
 		if err != nil {
@@ -1163,7 +1235,7 @@ func convertToUint64(t NumberTypeImpl_, v interface{}) (uint64, sql.ConvertInRan
 		return uint64(math.Round(v)), sql.InRange, nil
 	case decimal.Decimal:
 		if v.GreaterThan(dec_uint64_max) {
-			return math.MaxUint64, sql.InRange, nil
+			return math.MaxUint64, sql.OutOfRange, nil
 		} else if v.LessThan(dec_zero) {
 			ret, _ := dec_uint64_max.Sub(v).Float64()
 			return uint64(math.Round(ret)), sql.OutOfRange, nil

Original file line number	Diff line number	Diff line change
`@@ -120,7 +120,7 @@ func (i insertIter) Next(ctx sql.Context) (returnRow sql.Row, returnErr error)`
`120`	`120`	`ctxWithValues = context.WithValue(ctxWithValues, types.RowNumberKey, i.rowNumber)`
`121`	`121`	`ctxWithColumnInfo := ctx.WithContext(ctxWithValues)`
`122`	`122`	`converted, inRange, cErr := col.Type.Convert(ctxWithColumnInfo, row[idx])`
`123`		`- if cErr == nil && !inRange {`
	`123`	`+ if cErr == nil && inRange == sql.OutOfRange {`
`124`	`124`	`cErr = sql.ErrValueOutOfRange.New(row[idx], col.Type)`
`125`	`125`	`}`
`126`	`126`	`if cErr != nil {`
Original file line number	Diff line number	Diff line change
`@@ -61,7 +61,7 @@ func TestUpdateIgnoreConversions(t *testing.T) {`
`61`	`61`	`name: "inserting a negative into an unsigned int results in 0",`
`62`	`62`	`colType: types.Uint64,`
`63`	`63`	`value: int64(-1),`
`64`		`- expected: uint64(1<<64 - 1),`
	`64`	`+ expected: uint64(0),`
`65`	`65`	`valueType: types.Uint64,`
`66`	`66`	`},`
`67`	`67`	`}`