Length checking for inserted bit values

Author: zachmu

server/functions/bit.go

@@ -52,7 +52,7 @@ var bitin = framework.Function3{
 
 		expectedLength := pgtypes.GetCharLengthFromTypmod(typmod)
 		if array.BitLen() != uint(expectedLength) {
-			return nil, pgtypes.ErrInvalidSyntaxForType.New("bit", input)
+			return nil, pgtypes.ErrWrongLengthBit.New(len(input), expectedLength)
 		}
 
 		return array, nil

server/functions/framework/cast.go

@@ -174,10 +174,13 @@ func GetAssignmentCast(fromType *pgtypes.DoltgresType, toType *pgtypes.DoltgresT
 	}
 	// We check for the identity after checking the maps, as the identity may be overridden (such as for types that have
 	// parameters). If the "to" type is a string type, then we do not use the identity, and use the I/O conversion below.
-	if fromType.ID == toType.ID && fromType.TypCategory != pgtypes.TypeCategory_StringTypes {
+	if fromType.ID == toType.ID && fromType.TypCategory != pgtypes.TypeCategory_StringTypes && fromType.TypCategory != pgtypes.TypeCategory_BitStringTypes {
 		return IdentityCast
 	}
+
 	// All types have a built-in assignment cast to string types: https://www.postgresql.org/docs/15/sql-createcast.html
+	// This is also where length checks occur for types like char(n), varchar(n), bit(n), etc., which is not great
+	// TODO: move length checks to their own analyzer step
 	if toType.TypCategory == pgtypes.TypeCategory_StringTypes {
 		return func(ctx *sql.Context, val any, targetType *pgtypes.DoltgresType) (any, error) {
 			if val == nil {
@@ -189,6 +192,17 @@ func GetAssignmentCast(fromType *pgtypes.DoltgresType, toType *pgtypes.DoltgresT
 			}
 			return targetType.IoInput(ctx, str)
 		}
+	} else if toType.TypCategory == pgtypes.TypeCategory_BitStringTypes {
+		return func(ctx *sql.Context, val any, targetType *pgtypes.DoltgresType) (any, error) {
+			if val == nil {
+				return nil, nil
+			}
+			str, err := fromType.IoOutput(ctx, val)
+			if err != nil {
+				return nil, err
+			}
+			return targetType.IoInput(ctx, str)
+		}
 	}
 	return nil
 }
@@ -209,8 +223,8 @@ func GetImplicitCast(fromType *pgtypes.DoltgresType, toType *pgtypes.DoltgresTyp
 
 // addTypeCast registers the given type cast.
 func addTypeCast(mutex *sync.RWMutex,
-	castMap map[id.Type]map[id.Type]pgtypes.TypeCastFunction,
-	castArray map[id.Type][]*pgtypes.DoltgresType, cast TypeCast) error {
+		castMap map[id.Type]map[id.Type]pgtypes.TypeCastFunction,
+		castArray map[id.Type][]*pgtypes.DoltgresType, cast TypeCast) error {
 	mutex.Lock()
 	defer mutex.Unlock()
 
@@ -240,8 +254,8 @@ func getPotentialCasts(mutex *sync.RWMutex, castArray map[id.Type][]*pgtypes.Dol
 // getCast returns the type cast function that will cast the "from" type to the "to" type. Returns nil if such a cast is
 // not valid.
 func getCast(mutex *sync.RWMutex,
-	castMap map[id.Type]map[id.Type]pgtypes.TypeCastFunction,
-	fromType *pgtypes.DoltgresType, toType *pgtypes.DoltgresType, outerFunc getCastFunction) pgtypes.TypeCastFunction {
+		castMap map[id.Type]map[id.Type]pgtypes.TypeCastFunction,
+		fromType *pgtypes.DoltgresType, toType *pgtypes.DoltgresType, outerFunc getCastFunction) pgtypes.TypeCastFunction {
 	mutex.RLock()
 	defer mutex.RUnlock()
 

server/types/bit.go

@@ -16,8 +16,12 @@ package types
 
 import (
 	"github.com/dolthub/doltgresql/core/id"
+	"gopkg.in/src-d/go-errors.v1"
 )
 
+// ErrWrongLengthBit is returned when a value with the incorrect length is inserted into a Bit column.
+var ErrWrongLengthBit = errors.NewKind(`bit string length %d does not match type bit(%d)`)
+
 // Bit is a fixed-length bit string.
 var Bit = &DoltgresType{
 	ID:            toInternal("bit"),

testing/go/types_test.go

@@ -80,7 +80,7 @@ var typesTests = []ScriptTest{
 	},
 	{
 		Name:  "Bit type",
-		Focus: true, // no pgx support: unknown type with oid: 1560
+		Focus: true,
 		SetUpScript: []string{
 			"CREATE TABLE t_bit (id INTEGER primary key, v1 BIT(8));",
 			"INSERT INTO t_bit VALUES (1, B'11011010'), (2, B'00101011');",
@@ -93,11 +93,19 @@ var typesTests = []ScriptTest{
 					{2, pgtype.Bits{Bytes: []uint8{0x2b}, Len: 8, Valid: true}},
 				},
 			},
+			{
+				Query:       "INSERT INTO t_bit VALUES (3, B'101');",
+				ExpectedErr: "bit string length 3 does not match type bit(8)",
+			},
+			{
+				Query:       "INSERT INTO t_bit VALUES (3, B'1001000110');",
+				ExpectedErr: "bit string length 10 does not match type bit(8)",
+			},
 		},
 	},
 	{
 		Name: "Bit key",
-		Skip: true, // no pgx support: unknown type with oid: 1560
+		Skip: true, // no comparator in serialization layer
 		SetUpScript: []string{
 			"CREATE TABLE t_bit (id BIT(8) primary key, v1 BIT(8));",
 			"INSERT INTO t_bit VALUES (B'11011010', B'11011010'), (B'00101011', B'00101011');",
@@ -3009,8 +3017,8 @@ var typesTests = []ScriptTest{
 			"create table t_uuid2 (id int primary key, v1 uuid, v2 uuid);",
 			"create index on t_uuid2(v1, v2);",
 			"insert into t_uuid2 values " +
-					"(1, 'f47ac10b58cc4372a567-0e02b2c3d479', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'), " +
-					"(2, 'dcf783c8-49c2-44b4-8b90-34ad8c52ea1e', 'f99802e8-0018-4913-806c-bcad5d246d46');",
+				"(1, 'f47ac10b58cc4372a567-0e02b2c3d479', 'a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11'), " +
+				"(2, 'dcf783c8-49c2-44b4-8b90-34ad8c52ea1e', 'f99802e8-0018-4913-806c-bcad5d246d46');",
 		},
 		Assertions: []ScriptTestAssertion{
 			{