gorm day4

高级查询

高级查询

智能选择字段

GORM允许通过Select方法选择特定的字段，如果你在应用程序中经常使用此功能，你也可以定义一个较小的结构体，以实现调用API时自动选择特定的字段，例如：

go 复制代码

type User struct {
  ID     uint
  Name   string
  Age    int
  Gender string
  // 假设后面还有几百个字段...
}

type APIUser struct {
  ID   uint
  Name string
}

// 查询时会自动选择 `id`, `name` 字段
db.Model(&User{}).Limit(10).Find(&APIUser{})
// SELECT `id`, `name` FROM `users` LIMIT 10

解读：

在 GORM 中使用一个结构体模型（User）去查询，但最终将查询结果映射到另一个结构体（APIUser）中，这种方法允许你从包含许多字段的数据表中仅选择和映射部分字段到结果中，这对于性能优化和数据传输减少是非常有用的。

结构体定义：
User 结构体 代表数据库中的 users 表，假设这个表有很多字段，但在这个例子中只展示了几个字段（ID, Name, Age, Gender）。
APIUser 结构体定义了你想从 User 模型中查询并返回的字段（ID, Name）。

查询操作：

db.Model(&User{}).Limit(10).Find(&APIUser{})

.Find(&APIUser{})：执行查询，并期望将查询结果映射到 APIUser 结构体切片中。这里需要注意的是，正确的用法应该是将结果映射到 APIUser 类型的切片变量，如 var apiUsers []APIUser。

对应的SQL语句：SELECT id, name FROM users LIMIT 10

注意QueryFields模式会根据当前model的所有字段名称进行select

go 复制代码

db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{
  QueryFields: true,
})

db.Find(&user)
// SELECT `users`.`name`, `users`.`age`, ... FROM `users` // 带上这个选项

// Session Mode
db.Session(&gorm.Session{QueryFields: true}).Find(&user)
// SELECT `users`.`name`, `users`.`age`, ... FROM `users`

可能还是看不懂这有啥区别：

我来说一下区别，没用之前就是SELECT * FROM users，用了就是SELECT users.name, users.age, ... FROM users。

Locking（FOR UPDATE)

GORM支持多种类型的锁，例如：

go 复制代码

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`

db.Clauses(clause.Locking{
  Strength: "UPDATE",
  Options: "NOWAIT",
}).Find(&users)
// SELECT * FROM `users` FOR UPDATE NOWAIT

在 GORM 中，Clauses 方法允许你添加特定的 SQL 子句到查询中。在这些示例中，使用了 clause.Locking 来添加行锁定（Row Locking）到查询中，这是在处理并发数据库访问时非常有用的特性。

我认为要看懂这个首先要从语法层面知道用法：
GORM 中的 Clauses() 方法

在 GORM 中，Clauses() 方法用于向查询添加一或多个特定的 SQL 子句。这种方法提供了向生成的 SQL 语句中注入额外条件或修饰符的能力，从而使得查询更加灵活和强大。
语法解析：

Clauses() 方法接受一个或多个实现了 clause.Interface 接口的参数。GORM 预定义了许多如 clause.Where、clause.OrderBy 以及本例中的 clause.Locking 等结构体，用于表示不同类型的 SQL 子句。
使用 clause.Locking

clause.Locking 是 GORM 中用于控制行级锁（Row-Level Locking）的一个结构体，它通过 Clauses() 方法应用到查询中。clause.Locking 允许你指定锁的强度（如排他锁FOR UPDATE或共享锁FOR SHARE）和其他选项（如NOWAIT）。

例子1：基本的行锁定（FOR UPDATE)

go 复制代码

db.Clauses(clause.Locking{Strength: "UPDATE"}).Find(&users)

这行代码通过 FOR UPDATE 子句添加了一个排他锁（Exclusive Lock）到查询中。这意味着查询执行时，被选中的行将被锁定以防止其他事务修改这些行，直到当前事务完成。

Strength: "UPDATE"：指定使用排他锁。这会锁定选中的行，防止其他事务读取或修改这些行，直到当前事务提交。

生成的 SQL 语句是：SELECT * FROM users FOR UPDATE

例子 2: 共享锁 (FOR SHARE)

go 复制代码

db.Clauses(clause.Locking{
  Strength: "SHARE",
  Table: clause.Table{Name: clause.CurrentTable},
}).Find(&users)

Strength: "SHARE"：指定使用共享锁，允许其他事务读取被锁定的行，但不能修改。

Table: clause.Table{Name: clause.CurrentTable}：这里通过 Table 属性指定锁定操作应用于当前查询的主表上。clause.CurrentTable 是一个占位符，表示当前操作的主表.

例子 3: FOR UPDATE NOWAIT

db.Clauses(clause.Locking{

Strength: "UPDATE",

Options: "NOWAIT",

}).Find(&users)

Options: "NOWAIT"：表示如果无法立即获得锁，则不等待而直接失败。这可以避免数据库操作因等待锁而阻塞。

在这些例子中，Clauses() 方法充当了向 GORM 查询注入特定 SQL 子句的载体。通过传递 clause.Locking 结构体，你可以细致地控制查询时的行锁定行为，包括锁的类型和行为选项。这种方式使得你能够构建复杂且性能优化的数据库操作，尤其是在处理并发和数据一致性时。

子查询

什么是子查询？
子查询（Subquery）是嵌套在其他 SQL 查询中的查询。 子查询可以出现在 SELECT、FROM 或 WHERE 等子句中，允许你构建复杂的查询，如在查询的一个部分中使用另一个查询的结果。子查询通常在圆括号内指定，可以返回一个或多个值，根据其在外部查询中的用途而定。

子查询的类型
标量子查询： 返回单个值的子查询。它常用在可以放置单个值的地方，如条件表达式中。例如，用在 SELECT、WHERE 或 HAVING 子句中比较一个列和子查询返回的单一结果。

列子查询： 返回一列多个值的子查询。这种类型的子查询可以用在 IN 或 ANY 等操作符后面，用来比较列中的值与子查询返回的一系列值。

行子查询： 返回一行或多行多列的结果。这种子查询可以用在比较操作 中，特别是当需要比较多个列时。

表子查询： 返回一个完整的表。这种子查询常用在 FROM 子句中，将子查询的结果当作一个临时表来参与查询。

举个例子：
用在 WHERE 子句中的标量子查询

go 复制代码

SELECT * FROM employees
WHERE salary > (
  SELECT AVG(salary) FROM employees
);

这个查询返回薪水高于公司平均薪水的所有员工。

用在 FROM 子句中的表子查询

go 复制代码

SELECT AVG(tmp.salary) AS avg_salary
FROM (
  SELECT salary FROM employees WHERE department_id = 1
) AS tmp;

这个查询计算特定部门（ID 为 1）员工的平均薪水。

这个当时我看的不是很懂，解读一下：
1.SELECT salary FROM employees WHERE department_id = 1

这个就被称为表子查询，就是一个简单的查询,它从 employees 表中选择 department_id 为 1 的所有员工的薪水。这里的 department_id = 1 表明我们只对特定部门（假设为部门ID为1的部门）的员工感兴趣。
2.(...) AS tmp(临时表）

将上面的查询放在括号中，后面跟着 AS tmp，表示整个括号内的查询结果被视为一个临时表 ，这个临时表在外层查询中被命名为 tmp。tmp 是一个别名（alias），用于在外层查询中引用这个临时表的结果。
3.AVG(tmp.salary) AS avg_salary

在外层查询中，我们对这个临时表 tmp 使用了 AVG() 函数来计算平均薪水 。tmp.salary 指的是临时表 tmp 中的 salary 列。因为 tmp 实际上就是内嵌查询的结果集，所以你可以像引用真实表中的列一样引用它的列。
AS avg_salary 是对 AVG(tmp.salary) 计算结果的列名进行重命名。 这意味着结果集中这一列的名称将是 avg_salary。

现在看懂这个例子就不难了，内部的子查询结果被当作成一张临时表，然后命名为tmp，然后再对这个tmp做一次查询，这个就叫做外层查询。自己体会一下，这种就是表子查询。

用在 SELECT 子句中的子查询

go 复制代码

SELECT name, (
  SELECT COUNT(*) FROM orders WHERE orders.customer_id = customers.id
) AS orders_count
FROM customers;

这个查询为每个客户返回他们的订单数量。

我还是有点看不懂，这里做个解读：

这个 SQL 例子展示了如何使用子查询来为每个客户计算他们的订单数量。这是通过在 SELECT 语句中嵌入另一个 SELECT 语句（即子查询）来实现的。
主查询：

go 复制代码

SELECT name, (...) AS orders_count FROM customers;

这是外层的查询，它从 customers 表中选择所有客户的 name 字段。

对于每个客户，它还尝试计算一个名为 orders_count 的值，这个值是通过内嵌的子查询计算得到的。

子查询

go 复制代码

(SELECT COUNT(*) FROM orders WHERE orders.customer_id = customers.id)

这是嵌入在主查询中的子查询，它为每个正在处理的客户计算订单数量。

COUNT(*) 函数计算 orders 表中满足特定条件的行数。 在这个例子中，条件是 orders.customer_id = customers.id，这意味着我们只计算那些 customer_id 与当前正在处理的客户的 id 相匹配的订单行数。
子查询针对主查询中每个客户的行执行一次。这种类型的子查询称为相关子查询 ，因为它使用了外层查询（主查询）中的值（在这里是 customers.id）。

举个例子：

go 复制代码

假设 customers 表有如下数据：
id	name
1	Alice
2	Bob

go 复制代码

并且 orders 表有如下数据：
id	customer_id
1	1
2	1
3	2

执行这个查询后，你将得到类似以下的结果：

go 复制代码

name	orders_count
Alice	2
Bob	1

子查询在GORM中：

子查询可以嵌套在查询中，GORM允许在使用*gorm.DB对象作为参数时生成子查询

go 复制代码

db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
// SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");

subQuery := db.Select("AVG(age)").Where("name LIKE ?", "name%").Table("users")
db.Select("AVG(age) as avgage").Group("name").Having("AVG(age) > (?)", subQuery).Find(&results)
// SELECT AVG(age) as avgage FROM `users` GROUP BY `name` HAVING AVG(age) > (SELECT AVG(age) FROM `users` WHERE name LIKE "name%")

解读：

例子1：使用子查询过滤主查询的结果

go 复制代码

db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)

子查询部分：db.Table("orders").Select("AVG(amount)") 这部分是一个子查询，它从 orders 表中计算所有订单的平均金额（AVG(amount)）。

主查询：db.Where("amount > (?)", ...) 这部分是主查询，它查询 orders 表中金额（amount）大于子查询计算出的平均金额的所有订单。

结果：生成的 SQL 语句是 SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");。这个查询返回 orders 表中，订单金额超过平均订单金额的所有订单。

例子2：在 HAVING 子句中使用子查询

go 复制代码

subQuery := db.Select("AVG(age)").Where("name LIKE ?", "name%").Table("users")
db.Select("AVG(age) as avgage").Group("name").Having("AVG(age) > (?)", subQuery).Find(&results)

子查询定义：db.Select("AVG(age)").Where("name LIKE ?", "name%").Table("users") 这部分定义了一个子查询，它计算所有名字包含 "name" 的用户的平均年龄。

主查询：在主查询中，使用了 Group("name") 对 users 表的记录按照 name 进行分组，并计算每个分组的平均年龄（AVG(age) as avgage）。

HAVING 子句：在 Having("AVG(age) > (?)", subQuery) 中，主查询使用了 HAVING 子句来过滤那些组的平均年龄大于子查询计算出的平均年龄的组。

结果：生成的 SQL 是 SELECT AVG(age) as avgage FROM users GROUP BY name HAVING AVG(age) > (SELECT AVG(age) FROM users WHERE name LIKE "name%")。这个查询返回每个 name 分组的平均年龄，并且只包括那些平均年龄大于名字包含 "name" 的所有用户平均年龄的分组。

From 子查询

GORM允许您再Table方法中通过FROM子句使用子查询，例如：

go 复制代码

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

subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})
// SELECT * FROM (SELECT `name` FROM `users`) as u, (SELECT `name` FROM `pets`) as p

例子1：使用单个子查询

go 复制代码

db.Table("(?) as u", db.Model(&User{}).Select("name", "age")).Where("age = ?", 18}).Find(&User{})

这个例子中，首先构造了一个子查询：db.Model(&User{}).Select("name", "age")。这个子查询从 users 表中选择 name 和 age 两列。

然后，子查询被作为一个临时表 u 引入到外层查询中：.Table("(?) as u", ...)

在外层查询中，使用了 Where("age = ?", 18) 来筛选年龄等于 18 的记录。

最后，使用 Find(&User{}) 来执行查询并将结果映射到 User 结构体中。

go 复制代码

例1对应的SQL语句
SELECT * FROM (SELECT `name`, `age` FROM `users`) as u WHERE `age` = 18

例子 2: 结合两个子查询

go 复制代码

subQuery1 := db.Model(&User{}).Select("name")
subQuery2 := db.Model(&Pet{}).Select("name")
db.Table("(?) as u, (?) as p", subQuery1, subQuery2).Find(&User{})

这个例子中，定义了两个子查询 subQuery1 和 subQuery2。subQuery1 从 users 表中选择 name，而 subQuery2 从 pets 表中选择 name。

这两个子查询随后被引入到外层查询中，分别作为临时表 u 和 p：.Table("(?) as u, (?) as p", subQuery1, subQuery2)

使用 Find(&User{}) 执行外层查询，尽管这里的用法可能有点混淆，因为结果映射到了 User 结构体，而实际 SQL 语句似乎意图是联合两个不同表的查询结果。

go 复制代码

例子2对应的sql
SELECT * FROM (SELECT `name` FROM `users`) as u, (SELECT `name` FROM `pets`) as p

GROUP条件

使用GROUP调价你可以更轻松的编写复杂SQL

go 复制代码

db.Where(
    db.Where("pizza = ?", "pepperoni").Where(db.Where("size = ?", "small").Or("size = ?", "medium")),
).Or(
    db.Where("pizza = ?", "hawaiian").Where("size = ?", "xlarge"),
).Find(&Pizza{}).Statement

// SELECT * FROM `pizzas` WHERE (pizza = "pepperoni" AND (size = "small" OR size = "medium")) OR (pizza = "hawaiian" AND size = "xlarge")

这个例子我觉得在展示如何在GORM中构建一个复杂的查询条件，涉及到AND、OR逻辑以及如何组合它们。

看例子：

查询分解

第一部分 - 辣香肠披萨，小或中尺寸

go 复制代码

db.Where("pizza = ?", "pepperoni").Where(db.Where("size = ?", "small").Or("size = ?", "medium"))

这部分首先指定了披萨种类为辣香肠（pepperoni）

然后，它要求尺寸为小（small）或中（medium）。这是通过将两个 Where 条件用 .Or 方法连接起来实现的，表示这两个条件中的任一个满足即可。

第二部分：

go 复制代码

.Or(db.Where("pizza = ?", "hawaiian").Where("size = ?", "xlarge"))

.Or 方法用于将前面的查询条件与新的条件组合，表示这是一个新的可选分支。

这部分指定了披萨种类为夏威夷（hawaiian）并且尺寸为特大（xlarge）

组合条件：

这两部分条件通过 OR 逻辑连接，意味着满足任一条件的记录都会被选出。

go 复制代码

SELECT * FROM `pizzas` WHERE (pizza = "pepperoni" AND (size = "small" OR size = "medium")) OR (pizza = "hawaiian" AND size = "xlarge")
生成的SQL

带多个列的IN

带多个列的IN查询

go 复制代码

db.Where("(name, age, role) IN ?", [][]interface{}{{"jinzhu", 18, "admin"}, {"jinzhu2", 19, "user"}}).Find(&users)
// SELECT * FROM users WHERE (name, age, role) IN (("jinzhu", 18, "admin"), ("jinzhu 2", 19, "user"));

解读：

这个例子主要说明了如何执行包含多个列的查询，IN查询通常用于指定某个字段的多个可能值 ，但在这个高级用法中，它被用来同时指定多个字段的组合值。这种查询对于检索符合一组特定条件的记录非常有用。

go 复制代码

db.Where("(name, age, role) IN ?", [][]interface{}{{"jinzhu", 18, "admin"}, {"jinzhu2", 19, "user"}}).Find(&users)

(name, age, role) IN ?：这部分定义了查询条件。它表示你想要选择那些在 name、age 和 role 三个字段上同时匹配给定值的记录。这里，查询条件是一个组合，涉及到三个字段。