fix: append default VARCHAR length instead of hardcoding it in the ty…

…pe definition

+ use strings.EqualFold() for case-insensitive string comparison (SQL is case-insensitive)
+ Dialect interface now requires `DefaultVarcharLen()`
+ CreateTableQuery uses the length set in .Varchar() also for `bun:",type:varchar"`

dialect/mssqldialect/dialect.go

@@ -127,10 +127,12 @@ func (*Dialect) AppendBool(b []byte, v bool) []byte {
 	return strconv.AppendUint(b, uint64(num), 10)
 }
 
+func (d *Dialect) DefaultVarcharLen() int {
+	return 255
+}
+
 func sqlType(field *schema.Field) string {
 	switch field.DiscoveredSQLType {
-	case sqltype.VarChar:
-		return field.DiscoveredSQLType + "(255)"
 	case sqltype.Timestamp:
 		return datetimeType
 	case sqltype.Boolean:

dialect/mysqldialect/dialect.go

@@ -172,11 +172,12 @@ func (*Dialect) AppendJSON(b, jsonb []byte) []byte {
 	return b
 }
 
+func (d *Dialect) DefaultVarcharLen() int {
+	return 255
+}
+
 func sqlType(field *schema.Field) string {
-	switch field.DiscoveredSQLType {
-	case sqltype.VarChar:
-		return field.DiscoveredSQLType + "(255)"
-	case sqltype.Timestamp:
+	if field.DiscoveredSQLType == sqltype.Timestamp {
 		return datetimeType
 	}
 	return field.DiscoveredSQLType

dialect/pgdialect/sqltype.go

@@ -45,6 +45,10 @@ var (
 	jsonRawMessageType = reflect.TypeOf((*json.RawMessage)(nil)).Elem()
 )
 
+func (d *Dialect) DefaultVarcharLen() int {
+	return 0
+}
+
 func fieldSQLType(field *schema.Field) string {
 	if field.UserSQLType != "" {
 		return field.UserSQLType

dialect/sqlitedialect/dialect.go

@@ -87,6 +87,10 @@ func (d *Dialect) AppendBytes(b []byte, bs []byte) []byte {
 	return b
 }
 
+func (d *Dialect) DefaultVarcharLen() int {
+	return 0
+}
+
 func fieldSQLType(field *schema.Field) string {
 	switch field.DiscoveredSQLType {
 	case sqltype.SmallInt, sqltype.BigInt:

query_table_create.go

@@ -5,6 +5,7 @@ import (
 	"database/sql"
 	"sort"
 	"strconv"
+	"strings"
 
 	"github.com/uptrace/bun/dialect/feature"
 	"github.com/uptrace/bun/dialect/sqltype"
@@ -32,6 +33,7 @@ func NewCreateTableQuery(db *DB) *CreateTableQuery {
 			db:   db,
 			conn: db.DB,
 		},
+		varchar: db.Dialect().DefaultVarcharLen(),
 	}
 	return q
 }
@@ -82,6 +84,10 @@ func (q *CreateTableQuery) IfNotExists() *CreateTableQuery {
 	return q
 }
 
+// Varchar changes the default length for VARCHAR columns.
+// Because some dialects require that length is always specified for VARCHAR type,
+// we will use the exact user-defined type if length is set explicitly, as in `bun:",type:varchar(5)"`,
+// but assume the new default length when it's omitted, e.g. `bun:",type:varchar"`.
 func (q *CreateTableQuery) Varchar(n int) *CreateTableQuery {
 	q.varchar = n
 	return q
@@ -120,7 +126,7 @@ func (q *CreateTableQuery) WithForeignKeys() *CreateTableQuery {
 	return q
 }
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 func (q *CreateTableQuery) Operation() string {
 	return "CREATE TABLE"
@@ -221,12 +227,15 @@ func (q *CreateTableQuery) AppendQuery(fmter schema.Formatter, b []byte) (_ []by
 }
 
 func (q *CreateTableQuery) appendSQLType(b []byte, field *schema.Field) []byte {
-	if field.CreateTableSQLType != field.DiscoveredSQLType {
+	// Most of the time these two will match, but for the cases where DiscoveredSQLType is dialect-specific,
+	// e.g. pgdialect would change sqltype.SmallInt to pgTypeSmallSerial for columns that have `bun:",autoincrement"`
+	if !strings.EqualFold(field.CreateTableSQLType, field.DiscoveredSQLType) {
 		return append(b, field.CreateTableSQLType...)
 	}
 
-	if q.varchar > 0 &&
-		field.CreateTableSQLType == sqltype.VarChar {
+	// For all common SQL types except VARCHAR, both UserDefinedSQLType and DiscoveredSQLType specify the correct type,
+	// and we needn't modify it. For VARCHAR columns, we will stop to check if a valid length has been set in .Varchar(int).
+	if q.varchar > 0 && strings.EqualFold(field.CreateTableSQLType, sqltype.VarChar) {
 		b = append(b, "varchar("...)
 		b = strconv.AppendInt(b, int64(q.varchar), 10)
 		b = append(b, ")"...)

schema/dialect.go

@@ -30,9 +30,14 @@ type Dialect interface {
 	AppendBytes(b []byte, bs []byte) []byte
 	AppendJSON(b, jsonb []byte) []byte
 	AppendBool(b []byte, v bool) []byte
+
+	// DefaultVarcharLen should be returned for dialects in which specifying VARCHAR length
+	// is mandatory in queries that modify the schema (CREATE TABLE / ADD COLUMN, etc).
+	// Dialects that do not have such requirement may return 0, which should be interpreted so by the caller.
+	DefaultVarcharLen() int
 }
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 type BaseDialect struct{}
 
@@ -131,7 +136,7 @@ func (BaseDialect) AppendBool(b []byte, v bool) []byte {
 	return dialect.AppendBool(b, v)
 }
 
-//------------------------------------------------------------------------------
+// ------------------------------------------------------------------------------
 
 type nopDialect struct {
 	BaseDialect
@@ -168,3 +173,7 @@ func (d *nopDialect) OnTable(table *Table) {}
 func (d *nopDialect) IdentQuote() byte {
 	return '"'
 }
+
+func (d *nopDialect) DefaultVarcharLen() int {
+	return 0
+}