fix double negation

Author: elianddb

enginetest/queries/script_queries.go

@@ -122,6 +122,98 @@ type ScriptTestAssertion struct {
 // Unlike other engine tests, ScriptTests must be self-contained. No other tables are created outside the definition of
 // the tests.
 var ScriptTests = []ScriptTest{
+	{
+		// https://github.com/dolthub/dolt/issues/9927
+		// https://github.com/dolthub/dolt/issues/9053
+		Name: "double negation of integer minimum values",
+		SetUpScript: []string{
+			"CREATE TABLE t0(c0 BIGINT);",
+			"INSERT INTO t0(c0) VALUES (-9223372036854775808);",
+			"CREATE TABLE t1(c0 INT);",
+			"INSERT INTO t1(c0) VALUES (-2147483648);",
+			"CREATE TABLE t2(c0 SMALLINT);",
+			"INSERT INTO t2(c0) VALUES (-32768);",
+			"CREATE TABLE t3(c0 TINYINT);",
+			"INSERT INTO t3(c0) VALUES (-128);",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query:           "SELECT 128;",
+				Expected:        []sql.Row{{uint64(128)}},
+				ExpectedColumns: sql.Schema{{Name: "128", Type: types.Uint8}},
+			},
+			{
+				Query:           "SELECT -128;",
+				Expected:        []sql.Row{{int8(-128)}},
+				ExpectedColumns: sql.Schema{{Name: "-128", Type: types.Int8}},
+			},
+			{
+				Query:           "SELECT -(-128);",
+				Expected:        []sql.Row{{int16(128)}},
+				ExpectedColumns: sql.Schema{{Name: "-(-128)", Type: types.Int16}},
+			},
+			{
+				Query:           "SELECT -(-32768);",
+				Expected:        []sql.Row{{int32(32768)}},
+				ExpectedColumns: sql.Schema{{Name: "-(-32768)", Type: types.Int32}},
+			},
+			{
+				Query:           "SELECT -(-2147483648);",
+				Expected:        []sql.Row{{int64(2147483648)}},
+				ExpectedColumns: sql.Schema{{Name: "-(-2147483648)", Type: types.Int64}},
+			},
+			{
+				Query:           "SELECT -(-9223372036854775808)",
+				Expected:        []sql.Row{{"9223372036854775808"}},
+				ExpectedColumns: sql.Schema{{Name: "-(-9223372036854775808)", Type: types.InternalDecimalType}},
+			},
+			{
+				Query:       "SELECT -t0.c0 FROM t0;",
+				ExpectedErr: sql.ErrValueOutOfRange,
+			},
+			{
+				Query:    "SELECT -t1.c0 FROM t1;",
+				Expected: []sql.Row{{2147483648}},
+			},
+			{
+				Query:    "SELECT -t2.c0 FROM t2;",
+				Expected: []sql.Row{{32768}},
+			},
+			{
+				Query:    "SELECT -t3.c0 FROM t3;",
+				Expected: []sql.Row{{128}},
+			},
+			{
+				Query:    "SELECT -(-t1.c0 + 1) FROM t1;",
+				Expected: []sql.Row{{-2147483649}},
+			},
+			{
+				Query:    "SELECT -(-(t2.c0 - 1)) FROM t2;",
+				Expected: []sql.Row{{-32769}},
+			},
+			{
+				Query:    "SELECT -(-t3.c0 * 2) FROM t3;",
+				Expected: []sql.Row{{-256}},
+			},
+			{
+				Query:    "SELECT -(-(-128));",
+				Expected: []sql.Row{{int8(-128)}},
+			},
+			{
+				Query:    "SELECT -(-(-(-128)));",
+				Expected: []sql.Row{{int16(128)}},
+			},
+			{
+				Query:    "SELECT -(-NULL);",
+				Expected: []sql.Row{{nil}},
+			},
+			{
+				Query:           "SELECT -(-CAST(-128 AS SIGNED));",
+				Expected:        []sql.Row{{int64(-128)}},
+				ExpectedColumns: sql.Schema{{Name: "-(-CAST(-128 AS SIGNED))", Type: types.Int64}},
+			},
+		},
+	},
 	{
 		// https://github.com/dolthub/dolt/issues/9865
 		Name:    "Stored procedure containing a transaction does not return EOF",

sql/expression/arithmetic.go

@@ -26,7 +26,7 @@ import (
 	"github.com/dolthub/vitess/go/mysql"
 	"github.com/dolthub/vitess/go/vt/sqlparser"
 	"github.com/shopspring/decimal"
-	errors "gopkg.in/src-d/go-errors.v1"
+	"gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/types"
@@ -669,14 +669,15 @@ func mult(lval, rval interface{}) (interface{}, error) {
 // UnaryMinus is an unary minus operator.
 type UnaryMinus struct {
 	UnaryExpression
+	typ sql.Type
 }
 
 var _ sql.Expression = (*UnaryMinus)(nil)
 var _ sql.CollationCoercible = (*UnaryMinus)(nil)
 
 // NewUnaryMinus creates a new UnaryMinus expression node.
 func NewUnaryMinus(child sql.Expression) *UnaryMinus {
-	return &UnaryMinus{UnaryExpression{Child: child}}
+	return &UnaryMinus{UnaryExpression{Child: child}, child.Type()}
 }
 
 // Eval implements the sql.Expression interface.
@@ -724,6 +725,9 @@ func (e *UnaryMinus) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		return -n, nil
 	case int64:
 		if n == math.MinInt64 {
+			if _, ok := e.Child.(*Literal); ok {
+				return decimal.NewFromInt(n).Neg(), nil
+			}
 			return nil, sql.ErrValueOutOfRange.New("BIGINT", fmt.Sprintf("%d", n))
 		}
 		return -n, nil
@@ -759,20 +763,42 @@ func (e *UnaryMinus) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 
 // Type implements the sql.Expression interface.
 func (e *UnaryMinus) Type() sql.Type {
-	typ := e.Child.Type()
-	if !types.IsNumber(typ) {
+	// Literals can overflow their types on unary minus, so we need to promote them
+	if lit, ok := e.Child.(*Literal); ok {
+		v := lit.Value()
+		switch n := v.(type) {
+		case int8:
+			if n == math.MinInt8 {
+				e.typ = types.Int16
+			}
+		case int16:
+			if n == math.MinInt16 {
+				e.typ = types.Int32
+			}
+		case int32:
+			if n == math.MinInt32 {
+				e.typ = types.Int64
+			}
+		case int64:
+			if n == math.MinInt64 {
+				e.typ = types.InternalDecimalType
+			}
+		}
+	}
+
+	if !types.IsNumber(e.typ) {
 		return types.Float64
 	}
 
-	if typ == types.Uint32 {
+	if e.typ == types.Uint32 {
 		return types.Int32
 	}
 
-	if typ == types.Uint64 {
+	if e.typ == types.Uint64 {
 		return types.Int64
 	}
 
-	return e.Child.Type()
+	return e.typ
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.