介绍 Bun：一个 Golang ORM

Posted on by

SQL 优先

Bun 是用于 PostgreSQL、MySQL/MariaDB、MSSQL 和 SQLite的SQL 优先 Golang ORM 。

SQL-first 意味着您可以在 Go 中编写 SQL 查询，例如，这个 Bun 查询：

var num int
err := db.NewSelect().
    TableExpr("generate_series(1, 3)").
    Where("generate_series = ?", 3).
    Limit(10).
    Scan(ctx, &num)

生成以下 SQL：

SELECT *
FROM generate_series(1, 3)
WHERE generate_series = 123
LIMIT 10

? SQL 仍然存在，但由于占位符，Bun 可以帮助您生成长查询，同时防止 SQL 注入：

Where("id = ?", 123)     // WHERE id = 123
Where("id >= ?", 123)    // WHERE id >= 123
Where("id = ?", "hello") // WHERE id = 'hello'

Where("id IN (?)", bun.In([]int{1, 2, 3})) // WHERE id IN (1, 2, 3)

Where("? = ?", bun.Ident("column"), "value") // WHERE "column" = 'value'

使用 Bun，您可以编写非常复杂的查询，例如，以下 Bun 查询：

regionalSales := db.NewSelect().
	ColumnExpr("region").
	ColumnExpr("SUM(amount) AS total_sales").
	TableExpr("orders").
	GroupExpr("region")

topRegions := db.NewSelect().
	ColumnExpr("region").
	TableExpr("regional_sales").
	Where("total_sales > (SELECT SUM(total_sales) / 10 FROM regional_sales)")

var []items map[string]interface{}

err := db.NewSelect().
	With("regional_sales", regionalSales).
	With("top_regions", topRegions).
	ColumnExpr("region").
	ColumnExpr("product").
	ColumnExpr("SUM(quantity) AS product_units").
	ColumnExpr("SUM(amount) AS product_sales").
	TableExpr("orders").
	Where("region IN (SELECT region FROM top_regions)").
	GroupExpr("region").
	GroupExpr("product").
	Scan(ctx, &items)

生成以下 SQL：

WITH regional_sales AS (
    SELECT region, SUM(amount) AS total_sales
    FROM orders
    GROUP BY region
), top_regions AS (
    SELECT region
    FROM regional_sales
    WHERE total_sales > (SELECT SUM(total_sales)/10 FROM regional_sales)
)
SELECT region,
       product,
       SUM(quantity) AS product_units,
       SUM(amount) AS product_sales
FROM orders
WHERE region IN (SELECT region FROM top_regions)
GROUP BY region, product

结构和表

Bun 允许您使用基于结构的模型将 Go 结构映射到数据库表，例如，以下代码：

type Model struct {
    ID        int64 `bun:",pk,autoincrement"`
    Name      string `bun:",notnull"`
    CreatedAt time.Time `bun:",nullzero,default:now()"`
}

err := db.ResetModel(ctx, &Model{})

生成下表：

CREATE TABLE "models" (
  "id" BIGSERIAL NOT NULL,
  "name" VARCHAR NOT NULL,
  "created_at" TIMESTAMPTZ DEFAULT now(),
  PRIMARY KEY ("id"),
)

然后，您可以使用 Go 结构选择/插入/更新/删除行：

model := new(Model)
err := db.NewSelect().Model().Where("id = ?", 123).Scan(ctx)

model.ID = 0
res, err := db.NewInsert().Model(model).Exec(ctx)

res, err := db.NewUpdate().
    Model(model).
    Set("name = ?", "updated name").
    WherePK().
    Exec(ctx)

res, err := db.NewDelete().Model(model).WherePK().Exec(ctx)

有关详细信息，请参阅Bun 文档。

Golang ORM

那么Golang ORM部分呢？Bun 允许您使用 Go 结构定义常见的表关系，例如，这是您如何定义Author属于Book关系的方法：

type Book struct {
	ID		 int64
	AuthorID int64
	Author	 Author `bun:"rel:belongs-to,join:author_id=id"`
}

type Author struct {
	ID int64
}

然后使用Relation方法连接表：

err := db.NewSelect().
	Model(book).
	Relation("Author").
	Where("id = ?", 123).
	Scan(ctx)

SELECT
  "book"."id", "book"."title", "book"."text",
  "author"."id" AS "author__id", "author"."name" AS "author__name"
FROM "books"
LEFT JOIN "users" AS "author" ON "author"."id" = "book"."author_id"
WHERE id = 1

有关详细信息，请参阅ORM：表关系。

连接到数据库

Bun 工作在数据库/SQL 之上，并支持 PostgreSQL、MySQL/MariaDB、MSSQL 和 SQLite。

要连接到PostgreSQL数据库：

import (
	"github.com/uptrace/bun"
	"github.com/uptrace/bun/dialect/pgdialect"
    "github.com/uptrace/bun/driver/pgdriver"
)

dsn := "postgres://postgres:@localhost:5432/test?sslmode=disable"
sqldb := sql.OpenDB(pgdriver.NewConnector(pgdriver.WithDSN(dsn)))

db := bun.NewDB(sqldb, pgdialect.New())

要连接到MySQL数据库：

import (
	"github.com/uptrace/bun"
	"github.com/uptrace/bun/dialect/mysqldialect"
	_ "github.com/go-sql-driver/mysql"
)

sqldb, err := sql.Open("mysql", "root:pass@/test")
if err != nil {
	panic(err)
}

db := bun.NewDB(sqldb, mysqldialect.New())

要记录所有执行的查询，您可以安装bundebug 插件：

import "github.com/uptrace/bun/extra/bundebug"

db.AddQueryHook(bundebug.NewQueryHook(
	bundebug.WithVerbose(true), // log everything
))

执行查询

一旦你有了一个模型，你就可以开始执行查询了：

// Select a user by a primary key.
user := new(User)
err := db.NewSelect().Model(user).Where("id = ?", 1).Scan(ctx)

// Select first 10 users.
var users []User
err := db.NewSelect().Model(&users).OrderExpr("id ASC").Limit(10).Scan(ctx)

在扫描查询结果时，Bun 非常灵活，允许扫描到结构中：

user := new(User)
err := db.NewSelect().Model(user).Limit(1).Scan(ctx)

转化为标量：

var id int64
var name string
err := db.NewSelect().Model((*User)(nil)).Column("id", "name").Limit(1).Scan(ctx, &id, &name)

进入map[string]interface{}：

var m map[string]interface{}
err := db.NewSelect().Model((*User)(nil)).Limit(1).Scan(ctx, &m)

并分成上述类型的切片：

var users []User
err := db.NewSelect().Model(&users).Limit(1).Scan(ctx)

var ids []int64
var names []string
err := db.NewSelect().Model((*User)(nil)).Column("id", "name").Limit(1).Scan(ctx, &ids, &names)

var ms []map[string]interface{}
err := db.NewSelect().Model((*User)(nil)).Scan(ctx, &ms)

您还可以从插入/更新/删除查询返回结果并扫描它们：

var ids []int64
res, err := db.NewDelete().Model((*User)(nil)).Returning("id").Exec(ctx, &ids)

下一步是什么？

要开始使用，请参阅文档并运行示例。

Bun 带有许多插件，包括支持分布式跟踪和度量的OpenTelemetry工具。

使用跟踪，您可以使用与 OpenTelemetry 一起使用的开源跟踪工具之一来监控性能。许多DataDog 竞争对手也支持 OpenTelemetry。

此外，您可以将指标导出到 Prometheus并使用Grafana 或流行的替代方案将它们可视化。

推荐阅读：

分类： Go标签：