GORM 允许进行链式操作，所以您可以像这样写代码：

  1. db.Where("name = ?", "jinzhu").Where("age = ?", 18).First(&user)

GORM 中有三种类型的方法： 链式方法、Finisher 方法、新建会话方法

After a Chain method, Finisher Method, GORM returns an initialized *gorm.DB instance, which is NOT safe to reuse anymore, or new generated SQL might be polluted by the previous conditions, for example:

  1. queryDB := DB.Where("name = ?", "jinzhu")
  3. queryDB.First(&user)
  4. // SELECT * FROM users WHERE name = "jinzhu"
  6. queryDB.Where("name = ?", "jinzhu2").First(&user2)
  7. // SELECT * FROM users WHERE name = "jinzhu" AND name = "jinzhu2"

In order to reuse a initialized *gorm.DB instance, you can use a New Session Method to create a shareable *gorm.DB, e.g:

  1. queryDB := DB.Where("name = ?", "jinzhu").Session(&gorm.Session{})
  3. queryDB.First(&user)
  4. // SELECT * FROM users WHERE name = "jinzhu"
  6. queryDB.Where("name = ?", "jinzhu2").First(&user2)
  7. // SELECT * FROM users WHERE name = "jinzhu2"

链式方法

Chain methods are methods to modify or add Clauses to current Statement, like:

Where, Select, Omit, Joins, Scopes, Preload, Raw (Raw can’t be used with other chainable methods to build SQL)…

Here is the full lists, also check out the SQL Builder for more details about Clauses.

Finisher 方法

Finishers are immediate methods that execute registered callbacks, which will generate and execute SQL, like those methods:

Create, First, Find, Take, Save, Update, Delete, Scan, Row, Rows…

Check out the full lists here.

New Session Method

GORM defined Session, WithContext, Debug methods as New Session Method, refer Session for more details.

After a Chain method, Finisher Method, GORM returns an initialized *gorm.DB instance, which is NOT safe to reuse anymore, you should use a New Session Method to mark the *gorm.DB as shareable.

Let’s explain it with examples:

Example 1:

  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // db is a new initialized `*gorm.DB`, which is safe to reuse
  4. db.Where("name = ?", "jinzhu").Where("age = ?", 18).Find(&users)
  5. // `Where("name = ?", "jinzhu")` is the first chain method call, it will create an initialized `*gorm.DB` instance, aka `*gorm.Statement`
  6. // `Where("age = ?", 18)` is the second chain method call, it reuses the above `*gorm.Statement`, adds new condition `age = 18` to it
  7. // `Find(&users)` is a finisher method, it executes registered Query Callbacks, which generates and runs the following SQL:
  8. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18;
  10. db.Where("name = ?", "jinzhu2").Where("age = ?", 20).Find(&users)
  11. // `Where("name = ?", "jinzhu2")` is also the first chain method call, it creates a new `*gorm.Statement`
  12. // `Where("age = ?", 20)` reuses the above `Statement`, and add conditions to it
  13. // `Find(&users)` is a finisher method, it executes registered Query Callbacks, generates and runs the following SQL:
  14. // SELECT * FROM users WHERE name = 'jinzhu2' AND age = 20;
  16. db.Find(&users)
  17. // `Find(&users)` is a finisher method call, it also creates a new `Statement` and executes registered Query Callbacks, generates and runs the following SQL:
  18. // SELECT * FROM users;

(Bad) Example 2:

  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // db is a new initialized *gorm.DB, which is safe to reuse
  4. tx := db.Where("name = ?", "jinzhu")
  5. // `Where("name = ?", "jinzhu")` returns an initialized `*gorm.Statement` instance after chain method `Where`, which is NOT safe to reuse
  7. // good case
  8. tx.Where("age = ?", 18).Find(&users)
  9. // `tx.Where("age = ?", 18)` use the above `*gorm.Statement`, adds new condition to it
  10. // `Find(&users)` is a finisher method call, it executes registered Query Callbacks, generates and runs the following SQL:
  11. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18
  13. // bad case
  14. tx.Where("age = ?", 28).Find(&users)
  15. // `tx.Where("age = ?", 18)` also use the above `*gorm.Statement`, and keep adding conditions to it
  16. // So the following generated SQL is polluted by the previous conditions:
  17. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18 AND age = 28;

Example 3:

  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // db is a new initialized *gorm.DB, which is safe to reuse
  4. tx := db.Where("name = ?", "jinzhu").Session(&gorm.Session{})
  5. tx := db.Where("name = ?", "jinzhu").WithContext(context.Background())
  6. tx := db.Where("name = ?", "jinzhu").Debug()
  7. // `Session`, `WithContext`, `Debug` returns `*gorm.DB` marked as safe to reuse, newly initialized `*gorm.Statement` based on it keeps current conditions
  9. // good case
  10. tx.Where("age = ?", 18).Find(&users)
  11. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18
  13. // good case
  14. tx.Where("age = ?", 28).Find(&users)
  15. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 28;