vendor/github.com/jinzhu/gorm/dialect_common.go

   1 package gorm
   2
   3 import (
   4         "fmt"
   5         "reflect"
   6         "regexp"
   7         "strconv"
   8         "strings"
   9         "time"
  10 )
  11
  12 // DefaultForeignKeyNamer contains the default foreign key name generator method
  13 type DefaultForeignKeyNamer struct {
  14 }
  15
  16 type commonDialect struct {
  17         db SQLCommon
  18         DefaultForeignKeyNamer
  19 }
  20
  21 func init() {
  22         RegisterDialect("common", &commonDialect{})
  23 }
  24
  25 func (commonDialect) GetName() string {
  26         return "common"
  27 }
  28
  29 func (s *commonDialect) SetDB(db SQLCommon) {
  30         s.db = db
  31 }
  32
  33 func (commonDialect) BindVar(i int) string {
  34         return "$$$" // ?
  35 }
  36
  37 func (commonDialect) Quote(key string) string {
  38         return fmt.Sprintf(`"%s"`, key)
  39 }
  40
  41 func (s *commonDialect) fieldCanAutoIncrement(field *StructField) bool {
  42         if value, ok := field.TagSettingsGet("AUTO_INCREMENT"); ok {
  43                 return strings.ToLower(value) != "false"
  44         }
  45         return field.IsPrimaryKey
  46 }
  47
  48 func (s *commonDialect) DataTypeOf(field *StructField) string {
  49         var dataValue, sqlType, size, additionalType = ParseFieldStructForDialect(field, s)
  50
  51         if sqlType == "" {
  52                 switch dataValue.Kind() {
  53                 case reflect.Bool:
  54                         sqlType = "BOOLEAN"
  55                 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr:
  56                         if s.fieldCanAutoIncrement(field) {
  57                                 sqlType = "INTEGER AUTO_INCREMENT"
  58                         } else {
  59                                 sqlType = "INTEGER"
  60                         }
  61                 case reflect.Int64, reflect.Uint64:
  62                         if s.fieldCanAutoIncrement(field) {
  63                                 sqlType = "BIGINT AUTO_INCREMENT"
  64                         } else {
  65                                 sqlType = "BIGINT"
  66                         }
  67                 case reflect.Float32, reflect.Float64:
  68                         sqlType = "FLOAT"
  69                 case reflect.String:
  70                         if size > 0 && size < 65532 {
  71                                 sqlType = fmt.Sprintf("VARCHAR(%d)", size)
  72                         } else {
  73                                 sqlType = "VARCHAR(65532)"
  74                         }
  75                 case reflect.Struct:
  76                         if _, ok := dataValue.Interface().(time.Time); ok {
  77                                 sqlType = "TIMESTAMP"
  78                         }
  79                 default:
  80                         if _, ok := dataValue.Interface().([]byte); ok {
  81                                 if size > 0 && size < 65532 {
  82                                         sqlType = fmt.Sprintf("BINARY(%d)", size)
  83                                 } else {
  84                                         sqlType = "BINARY(65532)"
  85                                 }
  86                         }
  87                 }
  88         }
  89
  90         if sqlType == "" {
  91                 panic(fmt.Sprintf("invalid sql type %s (%s) for commonDialect", dataValue.Type().Name(), dataValue.Kind().String()))
  92         }
  93
  94         if strings.TrimSpace(additionalType) == "" {
  95                 return sqlType
  96         }
  97         return fmt.Sprintf("%v %v", sqlType, additionalType)
  98 }
  99
 100 func (s commonDialect) HasIndex(tableName string, indexName string) bool {
 101         var count int
 102         currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 103         s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.STATISTICS WHERE table_schema = ? AND table_name = ? AND index_name = ?", currentDatabase, tableName, indexName).Scan(&count)
 104         return count > 0
 105 }
 106
 107 func (s commonDialect) RemoveIndex(tableName string, indexName string) error {
 108         _, err := s.db.Exec(fmt.Sprintf("DROP INDEX %v", indexName))
 109         return err
 110 }
 111
 112 func (s commonDialect) HasForeignKey(tableName string, foreignKeyName string) bool {
 113         return false
 114 }
 115
 116 func (s commonDialect) HasTable(tableName string) bool {
 117         var count int
 118         currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 119         s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = ? AND table_name = ?", currentDatabase, tableName).Scan(&count)
 120         return count > 0
 121 }
 122
 123 func (s commonDialect) HasColumn(tableName string, columnName string) bool {
 124         var count int
 125         currentDatabase, tableName := currentDatabaseAndTable(&s, tableName)
 126         s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = ? AND table_name = ? AND column_name = ?", currentDatabase, tableName, columnName).Scan(&count)
 127         return count > 0
 128 }
 129
 130 func (s commonDialect) ModifyColumn(tableName string, columnName string, typ string) error {
 131         _, err := s.db.Exec(fmt.Sprintf("ALTER TABLE %v ALTER COLUMN %v TYPE %v", tableName, columnName, typ))
 132         return err
 133 }
 134
 135 func (s commonDialect) CurrentDatabase() (name string) {
 136         s.db.QueryRow("SELECT DATABASE()").Scan(&name)
 137         return
 138 }
 139
 140 func (commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string) {
 141         if limit != nil {
 142                 if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit >= 0 {
 143                         sql += fmt.Sprintf(" LIMIT %d", parsedLimit)
 144                 }
 145         }
 146         if offset != nil {
 147                 if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset >= 0 {
 148                         sql += fmt.Sprintf(" OFFSET %d", parsedOffset)
 149                 }
 150         }
 151         return
 152 }
 153
 154 func (commonDialect) SelectFromDummyTable() string {
 155         return ""
 156 }
 157
 158 func (commonDialect) LastInsertIDReturningSuffix(tableName, columnName string) string {
 159         return ""
 160 }
 161
 162 func (commonDialect) DefaultValueStr() string {
 163         return "DEFAULT VALUES"
 164 }
 165
 166 // BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference
 167 func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string {
 168         keyName := fmt.Sprintf("%s_%s_%s", kind, tableName, strings.Join(fields, "_"))
 169         keyName = regexp.MustCompile("[^a-zA-Z0-9]+").ReplaceAllString(keyName, "_")
 170         return keyName
 171 }
 172
 173 // IsByteArrayOrSlice returns true of the reflected value is an array or slice
 174 func IsByteArrayOrSlice(value reflect.Value) bool {
 175         return (value.Kind() == reflect.Array || value.Kind() == reflect.Slice) && value.Type().Elem() == reflect.TypeOf(uint8(0))
 176 }