Goqu 查询构建器：SelectDataset 使用指南-优快云博客

Goqu 查询构建器：SelectDataset 使用指南

【免费下载链接】goqu SQL builder and query library for golang 项目地址: https://gitcode.com/gh_mirrors/go/goqu

Goqu 是一个强大的 Go 语言 SQL 查询构建器，它提供了流畅的 API 来构建复杂的 SQL 查询。本文将详细介绍 Goqu 中 SelectDataset 的使用方法，帮助开发者高效地构建 SELECT 查询语句。

创建 SelectDataset

在 Goqu 中，有几种方式可以创建 SelectDataset：

基础创建方式

// 使用 From 创建
sql, _, _ := goqu.From("table").ToSQL()
fmt.Println(sql) // 输出: SELECT * FROM "table"

// 使用 Select 创建
sql, _, _ := goqu.Select(goqu.L("NOW()")).ToSQL()
fmt.Println(sql) // 输出: SELECT NOW()

指定方言创建

dialect := goqu.Dialect("mysql")

sql, _, _ := dialect.From("table").ToSQL()
fmt.Println(sql) // 输出: SELECT * FROM `table`

数据库连接创建

db := goqu.New("mysql", mysqlDB)

sql, _, _ := db.From("table").ToSQL()
fmt.Println(sql) // 输出: SELECT * FROM `table`

构建 SELECT 查询

选择特定列

sql, _, _ := goqu.From("test").Select("a", "b", "c").ToSQL()
// 输出: SELECT "a", "b", "c" FROM "test"

使用子查询

ds := goqu.From("test")
fromDs := ds.Select("age").Where(goqu.C("age").Gt(10))
sql, _, _ := ds.From().Select(fromDs).ToSQL()
// 输出: SELECT (SELECT "age" FROM "test" WHERE ("age" > 10))

选择字面量

sql, _, _ := goqu.From("test").Select(goqu.L("a + b").As("sum")).ToSQL()
// 输出: SELECT a + b AS "sum" FROM "test"

聚合函数

sql, _, _ := goqu.From("test").Select(
    goqu.COUNT("*").As("age_count"),
    goqu.MAX("age").As("max_age"),
    goqu.AVG("age").As("avg_age"),
).ToSQL()
// 输出: SELECT COUNT(*) AS "age_count", MAX("age") AS "max_age", AVG("age") AS "avg_age" FROM "test"

从结构体选择列

type myStruct struct {
    Name         string
    Address      string `db:"address"`
    EmailAddress string `db:"email_address"`
}

sql, _, _ := goqu.From("test").Select(&myStruct{}).ToSQL()
// 输出: SELECT "address", "email_address", "name" FROM "test"

高级查询功能

DISTINCT 去重

// 基本去重
sql, _, _ := goqu.From("test").Select("a", "b").Distinct().ToSQL()
// 输出: SELECT DISTINCT "a", "b" FROM "test"

// DISTINCT ON (PostgreSQL 特有)
sql, _, _ := goqu.From("test").Distinct("a").ToSQL()
// 输出: SELECT DISTINCT ON ("a") * FROM "test"

FROM 子句

// 覆盖原始 FROM
sql, _, _ := goqu.From("test").From("test2").ToSQL()
// 输出: SELECT * FROM "test2"

// 使用子查询作为 FROM
fromDs := goqu.From("test").Where(goqu.C("age").Gt(10))
sql, _, _ := goqu.From(fromDs).ToSQL()
// 输出: SELECT * FROM (SELECT * FROM "test" WHERE ("age" > 10)) AS "t1"

JOIN 操作

Goqu 支持多种 JOIN 类型：

// 内连接
sql, _, _ := goqu.From("test").Join(
    goqu.T("test2"),
    goqu.On(goqu.Ex{"test.fkey": goqu.I("test2.Id")}),
).ToSQL()
// 输出: SELECT * FROM "test" INNER JOIN "test2" ON ("test"."fkey" = "test2"."Id")

// 左外连接
sql, _, _ := goqu.From("test").LeftJoin(
    goqu.T("test2"),
    goqu.On(goqu.Ex{"test.fkey": goqu.I("test2.Id")}),
).ToSQL()
// 输出: SELECT * FROM "test" LEFT OUTER JOIN "test2" ON ("test"."fkey" = "test2"."Id")

// 交叉连接
sql, _, _ := goqu.From("test").CrossJoin(goqu.T("test2")).ToSQL()
// 输出: SELECT * FROM "test" CROSS JOIN "test2"

WHERE 条件

// 使用 Ex 创建 AND 条件
sql, _, _ := goqu.From("test").Where(goqu.Ex{
    "a": goqu.Op{"gt": 10},
    "b": goqu.Op{"lt": 10},
    "c": nil,
    "d": []string{"a", "b", "c"},
}).ToSQL()
// 输出: SELECT * FROM "test" WHERE (("a" > 10) AND ("b" < 10) AND ("c" IS NULL) AND ("d" IN ('a', 'b', 'c')))

// 使用 ExOr 创建 OR 条件
sql, _, _ := goqu.From("test").Where(goqu.ExOr{
    "a": goqu.Op{"gt": 10},
    "b": goqu.Op{"lt": 10},
    "c": nil,
    "d": []string{"a", "b", "c"},
}).ToSQL()
// 输出: SELECT * FROM "test" WHERE (("a" > 10) OR ("b" < 10) OR ("c" IS NULL) OR ("d" IN ('a', 'b', 'c')))

分页控制

// LIMIT
sql, _, _ := goqu.From("test").Limit(10).ToSQL()
// 输出: SELECT * FROM "test" LIMIT 10

// OFFSET
sql, _, _ := goqu.From("test").Offset(2).ToSQL()
// 输出: SELECT * FROM "test" OFFSET 2

分组和过滤

// GROUP BY
sql, _, _ := goqu.From("test").
    Select(goqu.SUM("income").As("income_sum")).
    GroupBy("age").
    ToSQL()
// 输出: SELECT SUM("income") AS "income_sum" FROM "test" GROUP BY "age"

// HAVING
sql, _, _ = goqu.From("test").GroupBy("age").Having(goqu.SUM("income").Gt(1000)).ToSQL()
// 输出: SELECT * FROM "test" GROUP BY "age" HAVING (SUM("income") > 1000)

WITH 子句 (CTE)

// 简单 CTE
sql, _, _ := goqu.From("one").
    With("one", goqu.From().Select(goqu.L("1"))).
    Select(goqu.Star()).
    ToSQL()
// 输出: WITH one AS (SELECT 1) SELECT * FROM "one"

// 带参数的 CTE
sql, _, _ = goqu.From("multi").
    With("multi(x,y)", goqu.From().Select(goqu.L("1"), goqu.L("2"))).
    Select(goqu.C("x"), goqu.C("y")).
    ToSQL()
// 输出: WITH multi(x,y) AS (SELECT 1, 2) SELECT "x", "y" FROM "multi"

执行查询

Goqu 提供了多种执行查询和扫描结果的方法：

ScanStructs - 将结果扫描到结构体切片
ScanStruct - 将单行结果扫描到结构体
ScanVals - 将单列结果扫描到基本类型切片
ScanVal - 将单列单行结果扫描到基本类型
Count - 获取查询结果计数
Pluck - 提取单列值到切片

总结

Goqu 的 SelectDataset 提供了强大而灵活的方式来构建 SQL 查询。通过链式调用，开发者可以轻松构建复杂的查询语句，包括 JOIN、子查询、CTE 等高级功能。其 API 设计直观，能够有效减少 SQL 拼接错误，提高开发效率。

本文介绍了 SelectDataset 的主要功能，但在实际开发中，Goqu 还支持更多高级特性，如窗口函数、事务处理等。掌握这些功能将帮助开发者构建更加高效可靠的数据库应用。

【免费下载链接】goqu SQL builder and query library for golang 项目地址: https://gitcode.com/gh_mirrors/go/goqu

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考