var users = []User{{Name: "jinzhu1"}, {Name: "jinzhu2"}, {Name: "jinzhu3"}} db.Create(&users)
for _, user := range users { user.ID // 1,2,3 }
您可以在使用 CreateInBatches 進行建立時指定批次大小，例如
var users = []User{{Name: "jinzhu_1"}, ...., {Name: "jinzhu_10000"}}
// batch size 100 db.CreateInBatches(users, 100)
準備陳述式模式
準備陳述式模式會建立準備好的陳述式並將其快取，以加速後續呼叫
// globally mode, all operations will create prepared stmt and cache to speed up db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{PrepareStmt: true})
// session mode, create prepares stmt and speed up current session operations tx := db.Session(&Session{PrepareStmt: true}) tx.First(&user, 1) tx.Find(&users) tx.Model(&user).Update("Age", 18)
DryRun 模式
產生 SQL 但不執行，可用於檢查或測試產生的 SQL
stmt := db.Session(&Session{DryRun: true}).Find(&user, 1).Statement stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = $1 // PostgreSQL stmt.SQL.String() //=> SELECT * FROM `users` WHERE `id` = ? // MySQL stmt.Vars //=> []interface{}{1}
Join 預載入
使用 INNER JOIN 預載入關聯，並會處理 null 資料以避免掃描失敗
db.Joins("Company").Joins("Manager").Joins("Account").Find(&users, "users.id IN ?", []int{1,2})
db.Where("name1 = @name OR name2 = @name", sql.Named("name", "jinzhu")).Find(&user) // SELECT * FROM `users` WHERE name1 = "jinzhu" OR name2 = "jinzhu"
db.Where("name1 = @name OR name2 = @name", map[string]interface{}{"name": "jinzhu2"}).First(&result3) // SELECT * FROM `users` WHERE name1 = "jinzhu2" OR name2 = "jinzhu2" ORDER BY `users`.`id` LIMIT 1
db.Raw( "SELECT * FROM users WHERE name1 = @name OR name2 = @name2 OR name3 = @name", sql.Named("name", "jinzhu1"), sql.Named("name2", "jinzhu2"), ).Find(&user) // SELECT * FROM users WHERE name1 = "jinzhu1" OR name2 = "jinzhu2" OR name3 = "jinzhu1"
// SELECT * FROM pizzas WHERE (pizza = 'pepperoni' AND (size = 'small' OR size = 'medium')) OR (pizza = 'hawaiian' AND size = 'xlarge')
子查詢
// Where SubQuery db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// From SubQuery db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18}).Find(&User{}) // SELECT * FROM (SELECT `name`,`age` FROM `users`) as u WHERE age = 18
db.Clauses(clause.OnConflict{ Columns: []clause.Column{{Name: "id"}}, DoUpdates: clause.Assignments(map[string]interface{}{"name": "jinzhu", "age": 18}), }).Create(&users) // MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET ***; SQL Server // INSERT INTO `users` *** ON DUPLICATE KEY UPDATE name="jinzhu", age=18; MySQL
db.Clauses(clause.OnConflict{ Columns: []clause.Column{{Name: "id"}}, DoUpdates: clause.AssignmentColumns([]string{"name", "age"}), }).Create(&users) // MERGE INTO "users" USING *** WHEN NOT MATCHED THEN INSERT *** WHEN MATCHED THEN UPDATE SET "name"="excluded"."name"; SQL Server // INSERT INTO "users" *** ON CONFLICT ("id") DO UPDATE SET "name"="excluded"."name", "age"="excluded"."age"; PostgreSQL // INSERT INTO `users` *** ON DUPLICATE KEY UPDATE `name`=VALUES(name),`age=VALUES(age); MySQL
鎖定
db.Clauses(clause.Locking{Strength: "UPDATE"}).Find(&users) // SELECT * FROM `users` FOR UPDATE
db.Clauses(clause.Locking{ Strength: "SHARE", Table: clause.Table{Name: clause.CurrentTable}, }).Find(&users) // SELECT * FROM `users` FOR SHARE OF `users`
最佳化器/索引/註解提示
import"gorm.io/hints"
// Optimizer Hints db.Clauses(hints.New("hint")).Find(&User{}) // SELECT * /*+ hint */ FROM `users`
// Index Hints db.Clauses(hints.UseIndex("idx_user_name")).Find(&User{}) // SELECT * FROM `users` USE INDEX (`idx_user_name`)
type User struct { Name string`gorm:"<-:create"`// allow read and create Name string`gorm:"<-:update"`// allow read and update Name string`gorm:"<-"`// allow read and write (create and update) Name string`gorm:"->:false;<-:create"`// createonly Name string`gorm:"->"`// readonly Name string`gorm:"-"`// ignored }
追蹤建立/更新時間/unix (毫秒/奈秒) 秒數，適用於多個欄位
type User struct { CreatedAt time.Time // Set to current time if it is zero on creating UpdatedAt int// Set to current unix seconds on updaing or if it is zero on creating Updated int64`gorm:"autoUpdateTime:nano"`// Use unix Nano seconds as updating time Updated2 int64`gorm:"autoUpdateTime:milli"`// Use unix Milli seconds as updating time Created int64`gorm:"autoCreateTime"`// Use unix seconds as creating time }
多個資料庫，讀取/寫入分割
GORM 提供多個資料庫，讀取/寫入分割支援，外掛程式為 DB Resolver，它也支援根據目前的結構/表格自動切換資料庫/表格，以及多個來源、複製品支援，並具有自訂負載平衡邏輯
// Query user having a role field in attributes db.First(&user, datatypes.JSONQuery("attributes").HasKey("role")) // Query user having orgs->orga field in attributes db.First(&user, datatypes.JSONQuery("attributes").HasKey("orgs", "orga"))
type User struct { ID uint Name string Age int Gender string // hundreds of fields }
type APIUser struct { ID uint Name string }
// Select `id`, `name` automatically when query db.Model(&User{}).Limit(10).Find(&APIUser{}) // SELECT `id`, `name` FROM `users` LIMIT 10
關聯批次模式
關聯模式支援批次資料，例如
// Find all roles for all users db.Model(&users).Association("Role").Find(&roles)
// Delete User A from all user's team db.Model(&users).Association("Team").Delete(&userA)
// Get unduplicated count of members in all user's team db.Model(&users).Association("Team").Count()
// For `Append`, `Replace` with batch data, argument's length need to equal to data's length or will returns error var users = []User{user1, user2, user3} // e.g: we have 3 users, Append userA to user1's team, append userB to user2's team, append userA, userB and userC to user3's team db.Model(&users).Association("Team").Append(&userA, &userB, &[]User{userA, userB, userC}) // Reset user1's team to userA，reset user2's team to userB, reset user3's team to userA, userB and userC db.Model(&users).Association("Team").Replace(&userA, &userB, &[]User{userA, userB, userC})
刪除時刪除關聯
刪除記錄時，您可以使用 Select 刪除選取的單一關聯/多個關聯/多對多關聯，例如
// delete user's account when deleting user db.Select("Account").Delete(&user)
// delete user's Orders, CreditCards relations when deleting user db.Select("Orders", "CreditCards").Delete(&user)
// delete user's has one/many/many2many relations when deleting user db.Select(clause.Associations).Delete(&user)
// delete user's account when deleting users db.Select("Account").Delete(&users)
// Safe for new initialized *gorm.DB for i := 0; i < 100; i++ { go db.Where(...).First(&user) }
tx := db.Where("name = ?", "jinzhu") // NOT Safe as reusing Statement for i := 0; i < 100; i++ { go tx.Where(...).First(&user) }
ctxDB := db.WithContext(ctx) // Safe after a `New Session Method` for i := 0; i < 100; i++ { go ctxDB.Where(...).First(&user) }
ctxDB := db.Where("name = ?", "jinzhu").WithContext(ctx) // Safe after a `New Session Method` for i := 0; i < 100; i++ { go ctxDB.Where(...).First(&user) // `name = 'jinzhu'` will apply to the query }
tx := db.Where("name = ?", "jinzhu").Session(&gorm.Session{}) // Safe after a `New Session Method` for i := 0; i < 100; i++ { go tx.Where(...).First(&user) // `name = 'jinzhu'` will apply to the query }
func(user *User) BeforeCreate(tx *gorm.DB) error { // Modify current operation through tx.Statement, e.g: tx.Statement.Select("Name", "Age") tx.Statement.AddClause(clause.OnConflict{DoNothing: true})
// Operations based on tx will runs inside same transaction without clauses of current one var role Role err := tx.First(&role, "name = ?", user.Role).Error // SELECT * FROM roles WHERE name = "admin" return err }
func(user *User) BeforeUpdate(tx *gorm.DB) error { if tx.Statement.Changed("Name", "Admin") { // if Name or Admin changed tx.Statement.SetColumn("Age", 18) }
if tx.Statement.Changed() { // if any fields changed tx.Statement.SetColumn("Age", 18) } returnnil }
db.Model(&user).Update("Name", "Jinzhu") // update field `Name` to `Jinzhu` db.Model(&user).Updates(map[string]interface{}{"name": "Jinzhu", "admin": false}) // update field `Name` to `Jinzhu`, `Admin` to false db.Model(&user).Updates(User{Name: "Jinzhu", Admin: false}) // Update none zero fields when using struct as argument, will only update `Name` to `Jinzhu`
db.Model(&user).Select("Name", "Admin").Updates(User{Name: "Jinzhu"}) // update selected fields `Name`, `Admin`，`Admin` will be updated to zero value (false) db.Model(&user).Select("Name", "Admin").Updates(map[string]interface{}{"Name": "Jinzhu"}) // update selected fields exists in the map, will only update field `Name` to `Jinzhu`
// Attention: `Changed` will only check the field value of `Update` / `Updates` equals `Model`'s field value, it returns true if not equal and the field will be saved db.Model(&User{ID: 1, Name: "jinzhu"}).Updates(map[string]interface{"name": "jinzhu2"}) // Changed("Name") => true db.Model(&User{ID: 1, Name: "jinzhu"}).Updates(map[string]interface{"name": "jinzhu"}) // Changed("Name") => false, `Name` not changed db.Model(&User{ID: 1, Name: "jinzhu"}).Select("Admin").Updates(map[string]interface{"name": "jinzhu2", "admin": false}) // Changed("Name") => false, `Name` not selected to update
db.Transaction(func(tx *gorm.DB)error { // do some database operations in the transaction (use 'tx' from this point, not 'db') if err := tx.Create(&Animal{Name: "Giraffe"}).Error; err != nil { // return any error will rollback return err }
