ORM常见问题

最新推荐文章于 2024-08-13 15:23:47 发布

独臂阿童木

最新推荐文章于 2024-08-13 15:23:47 发布

阅读量1k

点赞数

分类专栏： goLang # go语言基础文章标签： golang

本文链接：https://blog.csdn.net/zhw21w/article/details/130690162

版权

go语言基础同时被 2 个专栏收录

48 篇文章 2 订阅

订阅专栏

goLang

21 篇文章 1 订阅

订阅专栏

ORM常见问题解答

前言

结构体标签（tag）在 xorm 和 gorm 中都是用于定义数据库表和结构体字段之间映射关系的，但是它们的具体使用方式略有不同。

在 xorm 中，结构体字段的 tag 是由 xorm 标准和用户自定义两部分组成。其中，xorm 标准的 tag 包括：pk（主键）、notnull（非空）、autoincr（自增）、unique（唯一键）、index（索引）、default（默认值）、created（记录创建时间）、updated（记录更新时间）等。用户自定义的 tag 则可以通过 xorm:"tag_name" 的形式来定义。

在 gorm 中，结构体字段的 tag 则由 gorm 标准和用户自定义两部分组成。其中，gorm 标准的 tag 包括：primary_key（主键）、not null（非空）、auto_increment（自增）、unique_index（唯一键）、index（索引）、default（默认值）、created_at（记录创建时间）、updated_at（记录更新时间）、deleted_at（记录删除时间）等。用户自定义的 tag 则可以通过 gorm:"tag_name" 的形式来定义。

虽然 xorm 和 gorm 中的 tag 使用方式略有不同，但它们的本质都是用于将数据库表和结构体字段之间建立映射关系。因此，使用哪个 ORM 框架，应该根据自己的实际需求来选择。

XORM

1. XORM是什么？

XORM是一个简单而强大的Go语言ORM库，支持MySQL、PostgreSQL、SQLite、Oracle、mssql、TiDB等多种数据库，实现了对象关系映射，即ORM。

2. 如何使用XORM？

使用XORM，需要先安装XORM包，可以使用如下命令：

go get xorm.io/xorm
# or 
go install github.com/go-xorm/cmd/xorm@latest

安装完成后，可以使用XORM提供的Reverse功能来生成Go结构体，或者使用XORM提供的API操作数据库。

3. 如何使用XORM的Reverse功能生成Go结构体？

使用XORM的Reverse功能，需要先编写一个配置文件（比如config.yaml）

# 数据库引擎，支持的选项：mysql、postgres、mssql、sqlite3、oracle、odbc
dbType: mysql

# 数据库连接字符串，根据实际情况修改
connStr: root:password@tcp(localhost:3306)/test?charset=utf8mb4

# 数据库表前缀，可选项
tablePrefix: 

# 模型生成的路径
outputPath: models/

# 模型包名 
# 在生成的数据模型文件中修改包名为指定的包名。例如，如果 packageName 为 models，则需要将生成的数据模型文件中的 package main 修改为 package models
packageName: models  

# 模型所使用的标签，可选项
tag: xorm

# 指定数据表
tables:
	- users
  - orders

配置文件的详细说明可以查看XORM官方文档。然后，在终端执行以下命令即可：

xorm reverse config.yaml

生成结果实例:

// User Model
type User struct {
    Id   int64  `xorm:"'id' pk autoincr" json:"id"`
    Pwd  string `xorm:"'pwd'" json:"pwd"`
    Name string `xorm:"'name'" json:"name"`
}

每个标签之间都用分号分隔，每个标签的格式为 tag:"value"

生成的Go结构体中，默认使用xorm的标签。如果需要使用json标签，可以在配置文件中指定，例如：

tag: xorm json

除了在 config.yaml 文件中定义tables外，还可以在命令行添加，他俩本质上是一样的。其实都是命令行参数：

# --tables 参数用于指定要生成数据模型的数据库表，多个表名之间用逗号分隔
xorm reverse config.yaml --tables=users,orders
# 指定配置文件
xorm reverse --config=config.yaml --tables=table1,table2

除了之前提到的 dbType、connStr、tablePrefix、outputPath、packageName、tag 等参数，xorm reverse 命令的配置文件 config.yaml 还支持以下参数:

cache：是否使用缓存，默认为 false，建议生产环境下开启，以减轻数据库的压力。
cacheDir：缓存文件存储目录，默认为 .xormcache。
template：指定模板引擎，默认为 go，也可以设置为 mustache，pongo2，amber，ace，django，freemarker 等其他模板引擎。
templateDir：模板文件所在目录。
templateFile：模板文件名，需要包含扩展名。
goimports：是否使用 goimports 来格式化 Go 代码，默认为 false。若设置为 true，则会自动下载安装 goimports，因此需要保证网络畅通。
schemas：指定要生成的数据库表，可以是一个字符串，也可以是一个字符串数组，如：schemas: "user" 或 schemas: ["user", "product"]。
primaryKey：指定主键名称，默认为 "id"。
singularizeTableNames：是否对表名进行单数化处理，默认为 false。
camelCasedTableNames：是否对表名进行驼峰命名处理，默认为 false。
appendPkToTable：是否在表名后面添加主键名作为结尾，默认为 false。
generateMethods：是否生成表的增删改查操作方法，默认为 true。
generateUpdateMethod：是否生成表的更新操作方法，默认为 true。
generateDeleteMethod：是否生成表的删除操作方法，默认为 true。
generateInsertMethod：是否生成表的插入操作方法，默认为 true。
generateSelectMethod：是否生成表的查询操作方法，默认为 true。
generateExistMethod：是否生成表的存在性检查方法，默认为 true。
generateCountMethod：是否生成表的计数方法，默认为 true。
generateFindByMethod：是否生成表的单条记录查询方法，默认为 false。
generateFindOneMethod：是否生成表的单条记录查询方法，默认为 true。
generateRelationMethods：是否生成表之间关系查询方法，默认为 true。
generateLeftJoinMethod：是否生成表的左连接查询方法，默认为 true。
generateRightJoinMethod：是否生成表的右连接查询方法，默认为 true。
generateInnerJoinMethod：是否生成表的内连接查询方法，默认为 true。
generateAutoMigrate：是否自动创建数据表，默认为 false。
generateIndexMethods：是否生成表

在数据库中，一个数据库实例可以包含多个数据库，每个数据库可以包含多个表。在xorm中，schemas指的是数据库的名称（schema name），而tables指的是数据库中表的名称（table name）。

通常情况下，xorm会将schemas和tables配置为通配符（“*”），这样就可以对数据库中所有的表都生成数据模型。但如果需要生成特定数据库中的表的数据模型，就需要修改schemas和tables的配置，具体可以参考xorm的文档和配置示例。

Tips:

xorm 生成的数据模型默认使用的是 xorm 的标签，不支持直接生成 gorm 标签。不过，你可以手动修改生成的结构体，将 xorm 的标签改为 gorm 的标签。或者使用第三方的转换工具进行自动转换。例如，可以使用 gormt 工具将 xorm 标签转换为 gorm 标签。

可以使用 gormt 提供的 -transform 参数将 xorm 标签转换为 gorm 标签。

具体使用方法如下：

首先，使用 xorm 标签生成数据模型，例如：

gorment generate -t table1 -c "root:password@tcp(localhost:3306)/test" -p models -o models/ -t "xorm"

使用 gormt 工具将生成的模型文件中的 xorm 标签转换为 gorm 标签，例如：

gormt -f models/table1.go -transform=xorm2gorm -o models/

其中，-f 参数指定需要转换的文件路径，-transform 参数指定转换类型为 xorm2gorm，-o 参数指定输出路径。

转换完成后，可以在输出路径下找到转换后的文件，例如 models/table1.go 文件中的 xorm 标签被转换为了 gorm 标签。

4. XORM支持哪些数据库？

XORM支持MySQL、PostgreSQL、SQLite、Oracle、mssql、TiDB等多种数据库。

5. XORM提供哪些API？

XORM提供了众多的API，可以进行ORM操作、数据库连接池管理、Session管理等，详细信息请查看XORM官方文档。

Bee

1. Bee是什么？

Bee是一个基于Go语言的开发工具，可以用来快速开发Web应用程序。Bee提供了众多功能，包括路由、模板、ORM等。

2. Bee支持哪些ORM？

Bee支持xorm、gorm、QBS等ORM库，可以根据需要进行选择。

3. Bee如何使用ORM？

Bee默认使用xorm作为ORM库，可以在创建项目时指定ORM库，例如:

bee new myproject -orm=gorm

Bee还提供了Model生成工具，可以根据指定的字段快速生成模型文件，例如：

bee generate model User -fields="Id:int64,Pwd:string,Name:string" -orm=xorm -tags=json

# or 

bee generate model -driver=mysql -conn="root:123456@tcp(127.0.0.1:3306)/mydb?charset=utf8mb4" -tables="user" -pkg-model=models

其中，-driver指定数据库驱动，-conn指定数据库连接信息，-tables指定要生成模型的数据表，-pkg-model指定模型所属的包名。

生成的数据模型文件位于models目录下，示例代码如下：

package models

type User struct {
	Id      int    `xorm:"not null pk autoincr INT(11)"`
	Name    string `xorm:"not null VARCHAR(32)"`
	Age     int    `xorm:"not null INT(11)"`
	Address string `xorm:"VARCHAR(256)"`
}

也可以使用配置文件

配置信息，可以是json格式或 yaml格式

在conf/app.json文件中添加以下配置信息：

{
    "version": "1.0",
    "driver": "mysql",
    "conn": "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local",
    "dbprefix": "",
    "language": "go",
    "tables": [
        {
            "name": "user",
            "structName": "",
            "fields": [
                {
                    "name": "id",
                    "type": "int64",
                    "tag": "json:\"id\""
                },
                {
                    "name": "name",
                    "type": "string",
                    "tag": "json:\"name\""
                },
                {
                    "name": "email",
                    "type": "string",
                    "tag": "json:\"email\""
                },
                {
                    "name": "password",
                    "type": "string",
                    "tag": "json:\"password\""
                }
            ]
        }
    ]
}

在上述配置文件中，version 字段为配置文件的版本号，目前为 1.0。driver 和 conn 字段分别指定数据库的驱动和连接字符串。dbprefix 字段用于指定表名前缀。language 字段指定生成数据模型的语言，这里使用的是 Go。tables 字段是一个数组，每个元素是一个表的配置，包括表名、结构体名和字段等信息。

在 Bee 工具中，tables 命令中的 -fields 选项是用来指定数据表的字段信息的，这个选项是必须的，不能省略。如果不指定该选项，则 Bee 工具会报错提示缺少必要参数。

使用 Bee 工具生成数据模型时，可以通过 -config 参数指定配置文件路径。假设配置文件名为 config.yaml，则可以使用以下命令生成数据模型：

bee generate model <ModelName> -config=config.yaml

其中，<ModelName> 为要生成的数据模型的名称。

如果配置文件与 Bee 工具在同一目录下，则可以省略 -config 参数：

bee generate model <ModelName>

在配置文件中，可以通过 tables 字段指定要生成数据模型的数据库表信息，也可以通过 fields 字段指定要生成的字段信息。具体配置方式可以参考 Bee 工具官方文档。

命令解析：

bee generate model User -fields="Id:int64,Pwd:string,Name:string" -orm=xorm -tags=json

上面的命令将创建一个名为User的数据模型，该模型有三个字段：Id，Pwd和Name，并使用xorm和JSON标签。

在这个命令中，-fields选项用于指定模型的字段和类型，-orm选项用于指定使用的ORM框架，-tags选项用于指定用于生成JSON标签的结构体标记。
运行上述命令后，我们将在models目录下看到生成的user.go文件，其中包含有关我们的User数据模型的定义和xorm和JSON标记。

// User Model
type User struct {
    Id   int64  `xorm:"'id' pk autoincr" json:"id"`
    Pwd  string `xorm:"'pwd'" json:"pwd"`
    Name string `xorm:"'name'" json:"name"`
}

在这个示例中，我们使用了-fields、-orm和-tags选项来生成一个有xorm和JSON标签的User数据模型。

4. Bee支持哪些数据库？

Bee支持MySQL、PostgreSQL、SQLite等多种数据库。

5. Bee提供哪些API？

Bee提供了路由、模板、ORM等API，详细信息请查看Bee官方文档。

Gormt

1. Gormt是什么？

Gormt是一个用于生成Golang Gorm数据库模型的命令行工具。

2. 如何使用Gormt？

使用Gormt，需要先安装Gormt包，可以使用如下命令：

go get -u github.com/xxjwxc/gormt@latest

3. 如何使用 Gormt 生成数据模型？

使用以下命令可以生成数据模型：

gormt gen -d=<database> -h=<host> -p=<port> -u=<user> -pwd=<password> -o=<outputpath> -pkg=<package>

其中：

-d：数据库名称
-h：数据库服务器地址
-p：数据库端口号
-u：数据库用户名
-pwd：数据库密码
-o：生成的数据模型文件路径
-pkg：生成的数据模型所在的包名

或者定义配置文件

output: ./models
dialect: mysql
conn: root:password@tcp(localhost:3306)/test?charset=utf8mb4
tag: gorm
tables:
  - user
  - order

output：生成的模型文件存放路径
dialect：数据库类型，支持 mysql、postgresql、sqlite3、mssql 等多种数据库类型
conn：数据库连接字符串
tag：生成的模型中结构体标签的类型，默认是 gorm
tables：需要生成数据模型的数据库表名，可以指定多个

在项目跟目录执行以下命令：

gormt generate -f gormt.yaml

生成的gorm结构体默认使用的是gorm的tag，而不是xorm的tag。如果需要使用xorm的tag，需要在gormt的配置文件中进行相应的设置。可以在配置文件中添加TagToOrm选项，并将其值设置为xorm，这样生成的结构体就会使用xorm的tag了。例如：

# gormt 配置文件

# 数据库类型，支持 mysql、postgres 等
DbType: mysql

# 数据库连接信息
DbUrl: root:password@tcp(localhost:3306)/test?charset=utf8mb4

# 数据表前缀
TablePrefix: 

# 生成结构体的输出目录
OutPath: models/

# 生成结构体使用的包名
PkgName: models

# 使用 xorm 的 tag，而不是默认的 gorm 的 tag
TagToOrm: xorm

4. 如何在 Gormt 中添加 JSON 标签？

在 Gormt 中添加 JSON 标签的方法如下：

gormt gen -d=<database> -h=<host> -p=<port> -u=<user> -pwd=<password> -o=<outputpath> -pkg=<package> -tag=json

使用 -tag=json 参数可以在生成的结构体中添加 JSON 标签。

5. 如何在 Gormt 中添加 Gorm 标签？

在 Gormt 中添加 Gorm 标签的方法如下：

gormt gen -d=<database> -h=<host> -p=<port> -u=<user> -pwd=<password> -o=<outputpath> -pkg=<package> -orm=gorm

使用 -orm=gorm 参数可以在生成的结构体中添加 Gorm 标签。

6. Gormt 支持哪些数据库？

Gormt 目前支持 MySQL、PostgreSQL、SQLite 和 Microsoft SQL Server 这四种数据库。

7. Gormt 生成的结构体中默认使用的是哪种标签？

Gormt 生成的结构体默认使用的是 Gorm 标签。

8. Gormt 生成的结构体中可以同时添加多种标签吗？

可以，可以在命令中使用 -tag 参数指定需要添加的标签，例如：

gormt gen -d=<database> -h=<host> -p=<port> -u=<user> -pwd=<password> -o=<outputpath> -pkg=<package> -tag=json gormt

以上命令可以在生成的结构体中同时添加 JSON 和 Gorm 标签。

9. Gormt 生成的结构体中可以自定义函数吗？

可以，可以在模板文件中添加自定义函数。在模板文件中定义的自定义函数可以在生成的结构体中使用。

10. Gormt 有哪些模板文件可以使用？

Gormt 提供了多个模板文件供用户使用，可以根据需要选择使用。常用的模板文件有：

gormt: 生成 GORM 模型的默认模板，使用 GORM 的注释标签。
gormt2: 生成 GORM 模型的默认模板，使用 GORM v2 的注释标签。
gormt_xorm: 生成 XORM 模型的默认模板，使用 XORM 的注释标签。
gormt_sqlboiler: 生成 SQLBoiler 模型的默认模板，使用 SQLBoiler 的注释标签。
gormt_guregu: 生成 Guregu 模型的默认模板，使用 Guregu 的注释标签。

用户还可以根据自己的需求编写自定义模板文件。

Gormt 支持哪些数据库？ Gormt 支持 MySQL、PostgreSQL、SQLite、Microsoft SQL Server 和 Oracle 数据库。
Gormt 的安装和使用方法是什么？ Gormt 的安装和使用方法如下：
安装 Gormt：在命令行中运行 go get github.com/xxjwxc/gormt。
在数据库中创建表，并在表中添加注释。
在命令行中进入项目的根目录，运行 gormt gen -h，查看命令行参数和使用说明。
根据需求编写 Gormt 的配置文件 gormt.yaml。
在命令行中运行 gormt gen 命令，生成 GORM 模型。
Gormt 的优缺点是什么？ Gormt 的优点包括：

支持多种数据库。
支持自定义模板，方便用户根据自己的需求进行扩展。
支持生成 GORM v2 版本的模型。
使用简单，命令行参数和配置文件都很清晰。

Gormt 的缺点包括：

仅支持 GORM 框架，不支持其他框架。
在生成模型时，不支持对外键、联合主键等复杂场景的处理。
生成的模型文件过于冗长，缺乏一定的可读性。

总体来说，Gormt 是一个功能较为完善、易于使用的 ORM 模型生成工具，适合用于快速生成 GORM 模型的开发场景。

Gorment

Gorment 是一个使用 Go 语言开发的 ORM 框架，类似于 Gorm 和 Xorm。它支持多种数据库，包括 MySQL、PostgreSQL、SQLite3、MSSQL、Oracle 等，其支持自动代码生成，可以根据数据库表结构自动生成相应的数据模型。与其他 ORM 框架相比，Gorment 的特点是它支持异步操作，可以更好地利用 Go 语言的并发性能。

使用 Gorment

安装

可以使用以下命令来安装 Gorment：

go get -u github.com/volatiletech/gorment

使用

使用 Gorment 生成数据模型的方法与 Gormt 和 Xorm 差不多。我们可以使用 Gorment 的命令行工具 gorment-cli 来生成模型文件。具体步骤如下：

在项目的根目录下创建一个配置文件 gorment.yaml，用于指定数据库连接信息和生成模型文件的选项。下面是一个例子：

# 数据库引擎，支持的选项：mysql、postgres、mssql、sqlite3、oracle
dbType: mysql

# 数据库连接字符串，根据实际情况修改
connStr: root:password@tcp(localhost:3306)/test?charset=utf8mb4

# 数据库表前缀，可选项
tablePrefix: 

# 模型生成的路径
outputPath: models/

# 模型包名
packageName: models

# 模型所使用的标签，可选项
tag: gorm json

在命令行中执行以下命令：
```
gorment generate
```
执行该命令后，Gorment 会根据 gorment.yaml 文件中的配置信息自动生成数据模型。生成的模型文件会存放在 outputPath 指定的目录中，文件名为表名的单数形式。例如，如果数据库中有一个名为 users 的表，那么生成的模型文件名为 user.go。

生成的模型文件中会自动添加 gorm.Model 结构体，这是 Gorm 框架内置的一个模型结构体，包含了常见的数据库字段（ID、CreatedAt、UpdatedAt、DeletedAt）和一些常用的方法。除此之外，Gorment 还会自动添加字段和标签，其中标签由 tag 选项指定。在上面的例子中，Gorment 会自动添加 gorm 和 json 两个标签。

生成数据模型

使用 Gorment 生成数据模型非常简单，只需要执行以下命令：

gorment generate -t <table> -c <connection-string> -p <package-name> -o <output-path>

其中：

<table>：需要生成数据模型的数据库表名。
<connection-string>：数据库连接字符串，格式为 user:password@tcp(host:port)/database。
<package-name>：生成的数据模型所在的包名。
<output-path>：生成的数据模型文件所在的路径。

执行命令后，Gorment 将会自动生成相应的数据模型文件。

标签设置

Gorment 的默认标签是 gorm，如果需要设置其他标签，可以在生成数据模型命令中使用 -t 参数，例如：

gorment generate -t <table> -c <connection-string> -p <package-name> -o <output-path> -t "xorm json"

其中 -t "xorm json" 表示使用 xorm 和 json 两个标签。

对于 Gorment 中的命令 gorment generate 来说，两个 -t 参数是不冲突的，因为它们是针对不同的选项的。

第一个 -t 参数用于指定要生成数据模型的表名，如果不指定，则会生成所有表的数据模型。例如 -t my_table 表示只生成名为 my_table 的表的数据模型。

第二个 -t 参数用于指定生成的数据模型所使用的标签，可以指定多个标签，多个标签之间使用空格分隔。例如 -t "xorm json" 表示生成的数据模型中会同时包含 xorm 和 json 两个标签。