GORM 的方法链功能可实现平滑流畅的编码风格。 Here’s an example:

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

Method Categories

GORM 将方法分为三大类： Chain Methods, Finisher Methods, and New Session Methods.

Chain Methods

用于修改或追加目前 Clauses 的 Statement。 一些常见的链式方法包括：

  • Where
  • Select
  • Omit
  • Joins
  • Scopes
  • Preload
  • Raw (Note: Raw cannot be used in conjunction with other chainable methods to build SQL)

For a comprehensive list, visit GORM Chainable API. Also, the SQL Builder documentation offers more details about Clauses.

Finisher Methods

终结方法是即时的，执行生成和运行 SQL 命令的注册回调。 This category includes methods:

  • Create
  • First
  • Find
  • Take
  • Save
  • Update
  • Delete
  • Scan
  • Row
  • Rows

For the full list, refer to GORM Finisher API.

New Session Methods

更多详情，请参阅 Session 文档。

Reusability and Safety

A critical aspect of GORM is understanding when a *gorm.DB instance is safe to reuse. Following a Chain Method or Finisher Method, GORM returns an initialized *gorm.DB instance. 这个实例无法安全地重新使用，因为它可能会将先前操作中的状况带回，有可能导致被污染的 SQL 查询。 For example:

Example of Unsafe Reuse

  1. queryDB := DB.Where("name = ?", "jinzhu")
  3. // First query
  4. queryDB.Where("age > ?", 10).First(&user)
  5. // SQL: SELECT * FROM users WHERE name = "jinzhu" AND age > 10
  7. // Second query with unintended compounded condition
  8. queryDB.Where("age > ?", 20).First(&user2)
  9. // SQL: SELECT * FROM users WHERE name = "jinzhu" AND age > 10 AND age > 20

安全再利用的例子

To safely reuse a *gorm.DB instance, use a New Session Method:

  1. queryDB := DB.Where("name = ?", "jinzhu").Session(&gorm.Session{})
  3. // First query
  4. queryDB.Where("age > ?", 10).First(&user)
  5. // SQL: SELECT * FROM users WHERE name = "jinzhu" AND age > 10
  7. // Second query, safely isolated
  8. queryDB.Where("age > ?", 20).First(&user2)
  9. // SQL: SELECT * FROM users WHERE name = "jinzhu" AND age > 20

In this scenario, using Session(&gorm.Session{}) ensures that each query starts with a fresh context, preventing the pollution of SQL queries with conditions from previous operations. This is crucial for maintaining the integrity and accuracy of your database interactions.

Examples for Clarity

Let’s clarify with a few examples:

  • Example 1: Safe Instance Reuse
  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // 'db' is a newly initialized `*gorm.DB`, which is safe to reuse.
  4. db.where ("name = ?", "jinzhu").Where("age = ?", 18). ind(&用户)
  5. // 第一个`Where ("name = ?", "jinzhu")`是一个启动一个 `*gorm.DB` 实例或`*gorm.Statement`的链式方法。
  6. // The second `Where("age = ?", 18)` call adds a new condition to the existing `*gorm.Statement`.
  7. // `Find(&users)` is a finisher method, executing registered Query Callbacks, generating and running:
  8. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18;
  10. db.Where("name = ?", "jinzhu2").Where("age = ?", 20).Find(&users)
  11. // Here, `Where("name = ?", "jinzhu2")` starts a new chain, creating a fresh `*gorm.Statement`.
  12. // `Where("age = ?", 20)` adds to this new statement.
  13. // `Find(&users)` again finalizes the query, executing and generating:
  14. // SELECT * FROM users WHERE name = 'jinzhu2' AND age = 20;
  16. db.Find(&users)
  17. // Directly calling `Find(&users)` without any `Where` starts a new chain and executes:
  18. // SELECT * FROM users;

在这个例子中，每个方法调用链都是独立的，确保干净、无污染的 SQL 查询。

  • (Bad) 示例2：不安全的实例重用
  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // 'db' is a newly initialized *gorm.DB, safe for initial reuse.
  4. tx := db.Where("name = ?", "jinzhu")
  5. // `Where("name = ?", "jinzhu")` initializes a `*gorm.Statement` instance, which should not be reused across different logical operations.
  7. // Good case
  8. tx.Where("age = ?", 18).Find(&users)
  9. // Reuses 'tx' correctly for a single logical operation, executing:
  10. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18
  12. // Bad case
  13. tx.Where("age = ?", 28).Find(&users)
  14. // Incorrectly reuses 'tx', compounding conditions and leading to a polluted query:
  15. // SELECT * FROM users WHERE name = 'jinzhu' AND age = 18 AND age = 28;

In this bad example, reusing the tx variable leads to compounded conditions, which is generally not desirable.

  • 例3：使用新会话方法安全重新使用
  1. db, err := gorm.Open(sqlite.Open("test.db"), &gorm.Config{})
  2. // 'db' is a newly initialized *gorm.DB, 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` methods return a `*gorm.DB` instance marked as safe for reuse. They base a newly initialized `*gorm.Statement` on the 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;

在这个例子中，为每个逻辑操作正确使用新建会话方法 Session, WithContext, Debug 初始化一个 *gorm.DB实例，从而防止了条件污染，确保每个查询都是独立的，并且基于所提供的特定条件。

Overall, these examples illustrate the importance of understanding GORM’s behavior with respect to method chaining and instance management to ensure accurate and efficient database querying.