added more tests and refactored asSQLNull

Author: 1NepuNep1

internal/bind/params.go

@@ -51,52 +51,32 @@ func asUUID(v any) (value.Value, bool) {
 func asSQLNull(v any) (value.Value, bool) {
 	switch x := v.(type) {
 	case sql.NullBool:
-		if x.Valid {
-			return value.OptionalValue(value.BoolValue(x.Bool)), true
-		}
-		
-		return value.NullValue(types.Bool), true
+		return wrapWithNulls(x.Valid, value.BoolValue(x.Bool), types.Bool), true
 	case sql.NullFloat64:
-		if x.Valid {
-			return value.OptionalValue(value.DoubleValue(x.Float64)), true
-		}
-
-		return value.NullValue(types.Double), true
+		return wrapWithNulls(x.Valid, value.DoubleValue(x.Float64), types.Double), true
 	case sql.NullInt16:
-		if x.Valid {
-			return value.OptionalValue(value.Int16Value(x.Int16)), true
-		}
-
-		return value.NullValue(types.Int16), true
+		return wrapWithNulls(x.Valid, value.Int16Value(x.Int16), types.Int16), true
 	case sql.NullInt32:
-		if x.Valid {
-			return value.OptionalValue(value.Int32Value(x.Int32)), true
-		}
-
-		return value.NullValue(types.Int32), true
+		return wrapWithNulls(x.Valid, value.Int32Value(x.Int32), types.Int32), true
 	case sql.NullInt64:
-		if x.Valid {
-			return value.OptionalValue(value.Int64Value(x.Int64)), true
-		}
-
-		return value.NullValue(types.Int64), true
+		return wrapWithNulls(x.Valid, value.Int64Value(x.Int64), types.Int64), true
 	case sql.NullString:
-		if x.Valid {
-			return value.OptionalValue(value.TextValue(x.String)), true
-		}
-
-		return value.NullValue(types.Text), true
+		return wrapWithNulls(x.Valid, value.TextValue(x.String), types.Text), true
 	case sql.NullTime:
-		if x.Valid {
-			return value.OptionalValue(value.TimestampValueFromTime(x.Time)), true
-		}
-
-		return value.NullValue(types.Timestamp), true
+		return wrapWithNulls(x.Valid, value.TimestampValueFromTime(x.Time), types.Timestamp), true
 	}
 
 	return asSQLNullGeneric(v)
 }
 
+func wrapWithNulls(valid bool, val value.Value, t types.Type) value.Value {
+	if valid {
+		return value.OptionalValue(val)
+	}
+
+	return value.NullValue(t)
+}
+
 func asSQLNullGeneric(v any) (value.Value, bool) {
 	if v == nil {
 		return nil, false

internal/bind/params_test.go

@@ -1095,6 +1095,46 @@ func TestSQLNullTypes(t *testing.T) {
 			src:      sql.Null[int64]{V: 0, Valid: false},
 			expected: value.NullValue(types.Int64),
 		},
+		{
+			name:     "sql.Null[bool] valid",
+			src:      sql.Null[bool]{V: true, Valid: true},
+			expected: value.OptionalValue(value.BoolValue(true)),
+		},
+		{
+			name:     "sql.Null[bool] invalid",
+			src:      sql.Null[bool]{V: false, Valid: false},
+			expected: value.NullValue(types.Bool),
+		},
+		{
+			name:     "sql.Null[float64] valid",
+			src:      sql.Null[float64]{V: 3.14, Valid: true},
+			expected: value.OptionalValue(value.DoubleValue(3.14)),
+		},
+		{
+			name:     "sql.Null[float64] invalid",
+			src:      sql.Null[float64]{V: 0, Valid: false},
+			expected: value.NullValue(types.Double),
+		},
+		{
+			name:     "sql.Null[time.Time] valid",
+			src:      sql.Null[time.Time]{V: time.Date(2024, 2, 3, 4, 5, 6, 7, time.UTC), Valid: true},
+			expected: value.OptionalValue(value.TimestampValueFromTime(time.Date(2024, 2, 3, 4, 5, 6, 7, time.UTC))),
+		},
+		{
+			name:     "sql.Null[time.Time] invalid",
+			src:      sql.Null[time.Time]{V: time.Time{}, Valid: false},
+			expected: value.NullValue(types.Timestamp),
+		},
+		{
+			name:     "sql.Null[[]byte] valid",
+			src:      sql.Null[[]byte]{V: []byte("abc"), Valid: true},
+			expected: value.OptionalValue(value.BytesValue([]byte("abc"))),
+		},
+		{
+			name:     "sql.Null[[]byte] invalid",
+			src:      sql.Null[[]byte]{V: nil, Valid: false},
+			expected: value.NullValue(types.Bytes),
+		},
 	}
 
 	for _, tt := range tests {