Refactor DataTypeOf for postgres, mssql

dialect_common.go

@@ -3,7 +3,7 @@ package gorm
 import (
 	"fmt"
 	"reflect"
-	"strconv"
+	"strings"
 	"time"
 )
 
@@ -18,49 +18,55 @@ func (commonDialect) Quote(key string) string {
 }
 
 func (commonDialect) DataTypeOf(field *StructField) string {
-	var (
+	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field)
-		size        int
-		dataValue   = reflect.Indirect(reflect.New(field.Struct.Type))
-		tagSettings = field.TagSettings
-	)
 
-	if num, ok := tagSettings["SIZE"]; ok {
+	if sqlType == "" {
-		size, _ = strconv.Atoi(num)
+		switch dataValue.Kind() {
-	}
+		case reflect.Bool:
-
+			sqlType = "BOOLEAN"
-	switch dataValue.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
-	case reflect.Bool:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok {
-		return "BOOLEAN"
+				sqlType = "INTEGER AUTO_INCREMENT"
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
+			} else {
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
+				sqlType = "INTEGER"
-			return "INTEGER AUTO_INCREMENT"
+			}
-		}
+		case reflect.Int64, reflect.Uint64:
-		return "INTEGER"
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok {
-	case reflect.Int64, reflect.Uint64:
+				sqlType = "BIGINT AUTO_INCREMENT"
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
+			} else {
-			return "BIGINT AUTO_INCREMENT"
+				sqlType = "BIGINT"
-		}
+			}
-		return "BIGINT"
+		case reflect.Float32, reflect.Float64:
-	case reflect.Float32, reflect.Float64:
+			sqlType = "FLOAT"
-		return "FLOAT"
+		case reflect.String:
-	case reflect.String:
+			if size > 0 && size < 65532 {
-		if size > 0 && size < 65532 {
+				sqlType = fmt.Sprintf("VARCHAR(%d)", size)
-			return fmt.Sprintf("VARCHAR(%d)", size)
+			} else {
-		}
+				sqlType = "VARCHAR(65532)"
-		return "VARCHAR(65532)"
+			}
-	case reflect.Struct:
+		case reflect.Struct:
-		if _, ok := dataValue.Interface().(time.Time); ok {
+			if _, ok := dataValue.Interface().(time.Time); ok {
-			return "TIMESTAMP"
+				sqlType = "TIMESTAMP"
-		}
+			}
-	default:
+		default:
-		if _, ok := dataValue.Interface().([]byte); ok {
+			if _, ok := dataValue.Interface().([]byte); ok {
-			if size > 0 && size < 65532 {
+				if size > 0 && size < 65532 {
-				return fmt.Sprintf("BINARY(%d)", size)
+					sqlType = fmt.Sprintf("BINARY(%d)", size)
+				} else {
+					sqlType = "BINARY(65532)"
+				}
 			}
-			return "BINARY(65532)"
 		}
 	}
-	panic(fmt.Sprintf("invalid sql type %s (%s) for commonDialect", dataValue.Type().Name(), dataValue.Kind().String()))
+
+	if sqlType == "" {
+		panic(fmt.Sprintf("invalid sql type %s (%s) for commonDialect", dataValue.Type().Name(), dataValue.Kind().String()))
+	}
+
+	if strings.TrimSpace(additionalType) == "" {
+		return sqlType
+	}
+	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 
 func (c commonDialect) HasIndex(scope *Scope, tableName string, indexName string) bool {

dialect_mssql.go

@@ -3,7 +3,7 @@ package gorm
 import (
 	"fmt"
 	"reflect"
-	"strconv"
+	"strings"
 	"time"
 )
 
@@ -12,49 +12,55 @@ type mssql struct {
 }
 
 func (mssql) DataTypeOf(field *StructField) string {
-	var (
+	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field)
-		size        int
-		dataValue   = reflect.Indirect(reflect.New(field.Struct.Type))
-		tagSettings = field.TagSettings
-	)
 
-	if num, ok := tagSettings["SIZE"]; ok {
+	if sqlType == "" {
-		size, _ = strconv.Atoi(num)
+		switch dataValue.Kind() {
-	}
+		case reflect.Bool:
-
+			sqlType = "bit"
-	switch dataValue.Kind() {
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
-	case reflect.Bool:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
-		return "bit"
+				sqlType = "int IDENTITY(1,1)"
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
+			} else {
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
+				sqlType = "int"
-			return "int IDENTITY(1,1)"
+			}
-		}
+		case reflect.Int64, reflect.Uint64:
-		return "int"
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
-	case reflect.Int64, reflect.Uint64:
+				sqlType = "bigint IDENTITY(1,1)"
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
+			} else {
-			return "bigint IDENTITY(1,1)"
+				sqlType = "bigint"
-		}
+			}
-		return "bigint"
+		case reflect.Float32, reflect.Float64:
-	case reflect.Float32, reflect.Float64:
+			sqlType = "float"
-		return "float"
+		case reflect.String:
-	case reflect.String:
+			if size > 0 && size < 65532 {
-		if size > 0 && size < 65532 {
+				sqlType = fmt.Sprintf("nvarchar(%d)", size)
-			return fmt.Sprintf("nvarchar(%d)", size)
+			} else {
-		}
+				sqlType = "text"
-		return "text"
+			}
-	case reflect.Struct:
+		case reflect.Struct:
-		if _, ok := dataValue.Interface().(time.Time); ok {
+			if _, ok := dataValue.Interface().(time.Time); ok {
-			return "datetime2"
+				sqlType = "datetime2"
-		}
+			}
-	default:
+		default:
-		if _, ok := dataValue.Interface().([]byte); ok {
+			if _, ok := dataValue.Interface().([]byte); ok {
-			if size > 0 && size < 65532 {
+				if size > 0 && size < 65532 {
-				return fmt.Sprintf("varchar(%d)", size)
+					sqlType = fmt.Sprintf("varchar(%d)", size)
+				} else {
+					sqlType = "text"
+				}
 			}
-			return "text"
 		}
 	}
-	panic(fmt.Sprintf("invalid sql type %s (%s) for mssql", dataValue.Type().Name(), dataValue.Kind().String()))
+
+	if sqlType == "" {
+		panic(fmt.Sprintf("invalid sql type %s (%s) for mssql", dataValue.Type().Name(), dataValue.Kind().String()))
+	}
+
+	if strings.TrimSpace(additionalType) == "" {
+		return sqlType
+	}
+	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 
 func (s mssql) HasIndex(scope *Scope, tableName string, indexName string) bool {

dialect_postgres.go

@@ -5,7 +5,6 @@ import (
 	"database/sql/driver"
 	"fmt"
 	"reflect"
-	"strconv"
 	"strings"
 	"time"
 
@@ -21,52 +20,57 @@ func (postgres) BindVar(i int) string {
 }
 
 func (postgres) DataTypeOf(field *StructField) string {
-	var (
+	var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field)
-		size        int
-		dataValue   = reflect.Indirect(reflect.New(field.Struct.Type))
-		tagSettings = field.TagSettings
-	)
 
-	if num, ok := tagSettings["SIZE"]; ok {
+	if sqlType == "" {
-		size, _ = strconv.Atoi(num)
+		switch dataValue.Kind() {
+		case reflect.Bool:
+			sqlType = "boolean"
+		case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
+				sqlType = "serial"
+			} else {
+				sqlType = "integer"
+			}
+		case reflect.Int64, reflect.Uint64:
+			if _, ok := field.TagSettings["AUTO_INCREMENT"]; ok || field.IsPrimaryKey {
+				sqlType = "bigserial"
+			} else {
+				sqlType = "bigint"
+			}
+		case reflect.Float32, reflect.Float64:
+			sqlType = "numeric"
+		case reflect.String:
+			if size > 0 && size < 65532 {
+				sqlType = fmt.Sprintf("varchar(%d)", size)
+			} else {
+				sqlType = "text"
+			}
+		case reflect.Struct:
+			if _, ok := dataValue.Interface().(time.Time); ok {
+				sqlType = "timestamp with time zone"
+			}
+		case reflect.Map:
+			if dataValue.Type() == hstoreType {
+				sqlType = "hstore"
+			}
+		default:
+			if isByteArrayOrSlice(dataValue) {
+				sqlType = "bytea"
+			} else if isUUID(dataValue) {
+				sqlType = "uuid"
+			}
+		}
 	}
 
-	switch dataValue.Kind() {
+	if sqlType == "" {
-	case reflect.Bool:
+		panic(fmt.Sprintf("invalid sql type %s (%s) for postgres", dataValue.Type().Name(), dataValue.Kind().String()))
-		return "boolean"
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
-			return "serial"
-		}
-		return "integer"
-	case reflect.Int64, reflect.Uint64:
-		if _, ok := tagSettings["AUTO_INCREMENT"]; ok {
-			return "bigserial"
-		}
-		return "bigint"
-	case reflect.Float32, reflect.Float64:
-		return "numeric"
-	case reflect.String:
-		if size > 0 && size < 65532 {
-			return fmt.Sprintf("varchar(%d)", size)
-		}
-		return "text"
-	case reflect.Struct:
-		if _, ok := dataValue.Interface().(time.Time); ok {
-			return "timestamp with time zone"
-		}
-	case reflect.Map:
-		if dataValue.Type() == hstoreType {
-			return "hstore"
-		}
-	default:
-		if isByteArrayOrSlice(dataValue) {
-			return "bytea"
-		} else if isUUID(dataValue) {
-			return "uuid"
-		}
 	}
-	panic(fmt.Sprintf("invalid sql type %s (%s) for postgres", dataValue.Type().Name(), dataValue.Kind().String()))
+
+	if strings.TrimSpace(additionalType) == "" {
+		return sqlType
+	}
+	return fmt.Sprintf("%v %v", sqlType, additionalType)
 }
 
 func (s postgres) HasIndex(scope *Scope, tableName string, indexName string) bool {