github.com/cloudreve/Cloudreve/v3@v3.0.0-20240224133659-3edb00a6484c/models/dialects/dialect_sqlite.go (about) 1 package dialects 2 3 import ( 4 "fmt" 5 "reflect" 6 "regexp" 7 "strconv" 8 "strings" 9 "time" 10 11 "github.com/jinzhu/gorm" 12 ) 13 14 var keyNameRegex = regexp.MustCompile("[^a-zA-Z0-9]+") 15 16 // DefaultForeignKeyNamer contains the default foreign key name generator method 17 type DefaultForeignKeyNamer struct { 18 } 19 20 type commonDialect struct { 21 db gorm.SQLCommon 22 DefaultForeignKeyNamer 23 } 24 25 func (commonDialect) GetName() string { 26 return "common" 27 } 28 29 func (s *commonDialect) SetDB(db gorm.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 *gorm.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 *gorm.StructField) string { 49 var dataValue, sqlType, size, additionalType = gorm.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 currentDatabaseAndTable(dialect gorm.Dialect, tableName string) (string, string) { 101 if strings.Contains(tableName, ".") { 102 splitStrings := strings.SplitN(tableName, ".", 2) 103 return splitStrings[0], splitStrings[1] 104 } 105 return dialect.CurrentDatabase(), tableName 106 } 107 108 func (s commonDialect) HasIndex(tableName string, indexName string) bool { 109 var count int 110 currentDatabase, tableName := currentDatabaseAndTable(&s, tableName) 111 s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.STATISTICS WHERE table_schema = ? AND table_name = ? AND index_name = ?", currentDatabase, tableName, indexName).Scan(&count) 112 return count > 0 113 } 114 115 func (s commonDialect) RemoveIndex(tableName string, indexName string) error { 116 _, err := s.db.Exec(fmt.Sprintf("DROP INDEX %v", indexName)) 117 return err 118 } 119 120 func (s commonDialect) HasForeignKey(tableName string, foreignKeyName string) bool { 121 return false 122 } 123 124 func (s commonDialect) HasTable(tableName string) bool { 125 var count int 126 currentDatabase, tableName := currentDatabaseAndTable(&s, tableName) 127 s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.TABLES WHERE table_schema = ? AND table_name = ?", currentDatabase, tableName).Scan(&count) 128 return count > 0 129 } 130 131 func (s commonDialect) HasColumn(tableName string, columnName string) bool { 132 var count int 133 currentDatabase, tableName := currentDatabaseAndTable(&s, tableName) 134 s.db.QueryRow("SELECT count(*) FROM INFORMATION_SCHEMA.COLUMNS WHERE table_schema = ? AND table_name = ? AND column_name = ?", currentDatabase, tableName, columnName).Scan(&count) 135 return count > 0 136 } 137 138 func (s commonDialect) ModifyColumn(tableName string, columnName string, typ string) error { 139 _, err := s.db.Exec(fmt.Sprintf("ALTER TABLE %v ALTER COLUMN %v TYPE %v", tableName, columnName, typ)) 140 return err 141 } 142 143 func (s commonDialect) CurrentDatabase() (name string) { 144 s.db.QueryRow("SELECT DATABASE()").Scan(&name) 145 return 146 } 147 148 func (commonDialect) LimitAndOffsetSQL(limit, offset interface{}) (sql string) { 149 if limit != nil { 150 if parsedLimit, err := strconv.ParseInt(fmt.Sprint(limit), 0, 0); err == nil && parsedLimit >= 0 { 151 sql += fmt.Sprintf(" LIMIT %d", parsedLimit) 152 } 153 } 154 if offset != nil { 155 if parsedOffset, err := strconv.ParseInt(fmt.Sprint(offset), 0, 0); err == nil && parsedOffset >= 0 { 156 sql += fmt.Sprintf(" OFFSET %d", parsedOffset) 157 } 158 } 159 return 160 } 161 162 func (commonDialect) SelectFromDummyTable() string { 163 return "" 164 } 165 166 func (commonDialect) LastInsertIDReturningSuffix(tableName, columnName string) string { 167 return "" 168 } 169 170 func (commonDialect) DefaultValueStr() string { 171 return "DEFAULT VALUES" 172 } 173 174 // BuildKeyName returns a valid key name (foreign key, index key) for the given table, field and reference 175 func (DefaultForeignKeyNamer) BuildKeyName(kind, tableName string, fields ...string) string { 176 keyName := fmt.Sprintf("%s_%s_%s", kind, tableName, strings.Join(fields, "_")) 177 keyName = keyNameRegex.ReplaceAllString(keyName, "_") 178 return keyName 179 } 180 181 // NormalizeIndexAndColumn returns argument's index name and column name without doing anything 182 func (commonDialect) NormalizeIndexAndColumn(indexName, columnName string) (string, string) { 183 return indexName, columnName 184 } 185 186 // IsByteArrayOrSlice returns true of the reflected value is an array or slice 187 func IsByteArrayOrSlice(value reflect.Value) bool { 188 return (value.Kind() == reflect.Array || value.Kind() == reflect.Slice) && value.Type().Elem() == reflect.TypeOf(uint8(0)) 189 } 190 191 type sqlite struct { 192 commonDialect 193 } 194 195 func init() { 196 gorm.RegisterDialect("sqlite", &sqlite{}) 197 } 198 199 func (sqlite) GetName() string { 200 return "sqlite" 201 } 202 203 // Get Data Type for Sqlite Dialect 204 func (s *sqlite) DataTypeOf(field *gorm.StructField) string { 205 var dataValue, sqlType, size, additionalType = gorm.ParseFieldStructForDialect(field, s) 206 207 if sqlType == "" { 208 switch dataValue.Kind() { 209 case reflect.Bool: 210 sqlType = "bool" 211 case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uintptr: 212 if s.fieldCanAutoIncrement(field) { 213 field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT") 214 sqlType = "integer primary key autoincrement" 215 } else { 216 sqlType = "integer" 217 } 218 case reflect.Int64, reflect.Uint64: 219 if s.fieldCanAutoIncrement(field) { 220 field.TagSettingsSet("AUTO_INCREMENT", "AUTO_INCREMENT") 221 sqlType = "integer primary key autoincrement" 222 } else { 223 sqlType = "bigint" 224 } 225 case reflect.Float32, reflect.Float64: 226 sqlType = "real" 227 case reflect.String: 228 if size > 0 && size < 65532 { 229 sqlType = fmt.Sprintf("varchar(%d)", size) 230 } else { 231 sqlType = "text" 232 } 233 case reflect.Struct: 234 if _, ok := dataValue.Interface().(time.Time); ok { 235 sqlType = "datetime" 236 } 237 default: 238 if IsByteArrayOrSlice(dataValue) { 239 sqlType = "blob" 240 } 241 } 242 } 243 244 if sqlType == "" { 245 panic(fmt.Sprintf("invalid sql type %s (%s) for sqlite", dataValue.Type().Name(), dataValue.Kind().String())) 246 } 247 248 if strings.TrimSpace(additionalType) == "" { 249 return sqlType 250 } 251 return fmt.Sprintf("%v %v", sqlType, additionalType) 252 } 253 254 func (s sqlite) HasIndex(tableName string, indexName string) bool { 255 var count int 256 s.db.QueryRow(fmt.Sprintf("SELECT count(*) FROM sqlite_master WHERE tbl_name = ? AND sql LIKE '%%INDEX %v ON%%'", indexName), tableName).Scan(&count) 257 return count > 0 258 } 259 260 func (s sqlite) HasTable(tableName string) bool { 261 var count int 262 s.db.QueryRow("SELECT count(*) FROM sqlite_master WHERE type='table' AND name=?", tableName).Scan(&count) 263 return count > 0 264 } 265 266 func (s sqlite) HasColumn(tableName string, columnName string) bool { 267 var count int 268 s.db.QueryRow(fmt.Sprintf("SELECT count(*) FROM sqlite_master WHERE tbl_name = ? AND (sql LIKE '%%\"%v\" %%' OR sql LIKE '%%%v %%');", columnName, columnName), tableName).Scan(&count) 269 return count > 0 270 } 271 272 func (s sqlite) CurrentDatabase() (name string) { 273 var ( 274 ifaces = make([]interface{}, 3) 275 pointers = make([]*string, 3) 276 i int 277 ) 278 for i = 0; i < 3; i++ { 279 ifaces[i] = &pointers[i] 280 } 281 if err := s.db.QueryRow("PRAGMA database_list").Scan(ifaces...); err != nil { 282 return 283 } 284 if pointers[1] != nil { 285 name = *pointers[1] 286 } 287 return 288 }