Merge pull request #3208 from dolthub/elian/9817

dolthub/dolt#9817 - Fix binary operations return type to be uint64

Author: elianddb

enginetest/queries/query_plans.go

@@ -91,17 +91,8 @@ func (b *BitOp) Type() sql.Type {
 		return lTyp
 	}
 
-	if types.IsText(lTyp) || types.IsText(rTyp) {
-		return types.Float64
-	}
-
-	if types.IsUnsigned(lTyp) && types.IsUnsigned(rTyp) {
-		return types.Uint64
-	} else if types.IsSigned(lTyp) && types.IsSigned(rTyp) {
-		return types.Int64
-	}
-
-	return types.Float64
+	// MySQL bitwise operations always return unsigned results, even for signed operands.
+	return types.Uint64
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.
@@ -168,7 +159,20 @@ func (b *BitOp) evalLeftRight(ctx *sql.Context, row sql.Row) (interface{}, inter
 }
 
 func (b *BitOp) convertLeftRight(ctx *sql.Context, left interface{}, right interface{}) (interface{}, interface{}, error) {
-	typ := b.Type()
+	// Determine the appropriate conversion type based on operand types
+	var typ sql.Type
+	lTyp := b.LeftChild.Type()
+	rTyp := b.RightChild.Type()
+
+	if types.IsText(lTyp) || types.IsText(rTyp) {
+		typ = types.Float64
+	} else if types.IsUnsigned(lTyp) && types.IsUnsigned(rTyp) {
+		typ = types.Uint64
+	} else if types.IsSigned(lTyp) && types.IsSigned(rTyp) {
+		typ = types.Int64
+	} else {
+		typ = types.Float64
+	}
 
 	left = convertValueToType(ctx, typ, left, types.IsTime(b.LeftChild.Type()))
 	right = convertValueToType(ctx, typ, right, types.IsTime(b.RightChild.Type()))

sql/expression/bit_ops.go

@@ -196,3 +196,44 @@ func TestAllUint64(t *testing.T) {
 		})
 	}
 }
+
+func TestBitOpType(t *testing.T) {
+	testCases := []struct {
+		name         string
+		leftType     sql.Type
+		rightType    sql.Type
+		expectedType sql.Type
+		description  string
+	}{
+		{"unsigned & unsigned", types.Uint64, types.Uint64, types.Uint64, "Both operands are unsigned"},
+		{"signed & signed", types.Int64, types.Int64, types.Uint64, "Both operands are signed - should return Uint64"},
+		{"mixed signed & unsigned", types.Int64, types.Uint64, types.Uint64, "Mixed signed/unsigned operands"},
+		{"text & text", types.Text, types.Text, types.Uint64, "Text operands should return Float64"},
+		{"text & int", types.Text, types.Int64, types.Uint64, "Mixed text and numeric operands"},
+		{"float & float", types.Float64, types.Float64, types.Uint64, "Float operands should return Uint64"},
+	}
+
+	operations := []struct {
+		name string
+		op   func(left, right sql.Expression) *BitOp
+	}{
+		{"BitAnd", NewBitAnd},
+		{"BitOr", NewBitOr},
+		{"BitXor", NewBitXor},
+		{"ShiftLeft", NewShiftLeft},
+		{"ShiftRight", NewShiftRight},
+	}
+
+	for _, tt := range testCases {
+		for _, op := range operations {
+			t.Run(tt.name+"_"+op.name, func(t *testing.T) {
+				require := require.New(t)
+				bitOp := op.op(NewLiteral(1, tt.leftType), NewLiteral(1, tt.rightType))
+				actualType := bitOp.Type()
+				require.Equal(tt.expectedType, actualType,
+					"BitOp.Type() should return %v for %s: %s",
+					tt.expectedType, tt.name, tt.description)
+			})
+		}
+	}
+}