go Gorm连接数据库，并实现增删改查操作

最新推荐文章于 2024-05-22 15:46:52 发布
最新推荐文章于 2024-05-22 15:46:52 发布
阅读量1.1k 收藏 2
点赞数 3
分类专栏： go 文章标签： golang 数据库 adb 后端 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_66100833/article/details/132920354
版权

Gorm

1. 准备工作

首先进入终端下载我们需要的包（确保go和mysql安装完成，并设置了环境变量）

go get -u gorm.io/driver/mysql
go get -u gorm.io/gorm

有两份官方文档有对 GORM 更详细的讲解。

  1. 创建 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.（中文）
  2. go-sql-driver/mysql: Go MySQL Driver is a MySQL driver for Go’s (golang) database/sql package (github.com)
2. 连接数据库

这里以mysql为例，其他数据库请看官方文档。

import (
  "gorm.io/driver/mysql"
  "gorm.io/gorm"
)

func main() {
  // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
  dsn := "user:pass@tcp(127.0.0.1:3306)/dbname?charset=utf8mb4&parseTime=True&loc=Local"
  db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
}

user -> 用户名

pass -> 密码

127.0.0.1 -> mysql默认本地地址，也就是localhost

3306 -> mysql默认端口

dbname -> 数据库名称

charset -> 字符集编码

parseTime -> 把数据库datetime和date类型转换为golang的time.Time类型

loc -> 使用系统本地时区

gorm.config{} 中可以进行一些高级配置，详情请看官方文档。

例如：

我们可以在其中写入：
Logger: logger.Default.LogMode(logger.Info)

这个句子的作用是配置GORM库，告诉它使用默认的日志记录器并将日志模式设置为信息级别（logger.Info），以便在终端中输出有关数据库操作的信息。

这样我们在对使用GORM的时候就可以在终端中看到输出的对应SQL语句了。

3. 结构体与mysql table 的映射关系

go的orm框架可以让我们在用go语言实现数据库操作的时候不使用sql语言，简单易上手，提高开发效率。

下面是gorm中go与mysql的对应关系

GOmysql
结构体数据表
结构体实例数据行
结构体字段字段

例如，一个结构体：

type Student struct {
	ID                int
	Name              string
	age               int
	ExternalCharacter string
}

gorm 会将其映射为

CREATE TABLE `students` (
    `id` bigint AUTO_INCREMENT,
    `name` longtext,
    `external_character` longtext,
    PRIMARY KEY (`id`)
)

这里可以发现，结构体字段中的大写都变成了小写，age完全消失，Student也变成了students，ExternalCharacter变成了external_character。这里涉及到了gorm的映射规定。

具体可看模型定义 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

简单来说，就是咱要首字母大写，会按驼峰命名法给我们加 _ 符号，默认ID 为主键，表名会变成复数。

再看数据类型，明显这是不知道有多大所以往大了去调。

当然，这些我们也是能够一一自定义的。

3.1. 表名：

实现Tabler接口 中的TableName函数。

例如，针对上述的结构体，我们可以这样写：

func (s *Student) TableName() string {
	return "student"
}

这样表名就会被映射为student而不是students

3.2 字段名：

我们可以在字段后面打上gorm tag，tag有很多用途，比如标记主键，指定not null等等，具体请看官方文档。

这里介绍自定义字段名，还是以上述的结构体为例：

type Student struct {
	ID                int `gorm:"column:序号"`
	Name              string
	age               int
	ExternalCharacter string `gorm:"column:externalCharacter"`
}

如果我们改成这样的话，映射的表就是这样的：

CREATE TABLE `student` (
    `序号` bigint AUTO_INCREMENT,
    `name` longtext,
    `externalCharacter` longtext,
    PRIMARY KEY (`序号`)
)
3.2 数据类型

将longtext改成 varchar(255) ，也是通过tag实现的。通过size:255来确定最大长度

把bigint改成int只需要将int改成int32就行了，因为go中，咱64位的电脑默认int是int64

例如：

type Student struct {
	ID                int32
	Name              string
	age               int
	ExternalCharacter string `gorm:"column:externalCharacter; size:255"`
}

映射出来的表就是这样的

CREATE TABLE `student` (
    `id` int AUTO_INCREMENT,
    `name` longtext,
    `externalCharacter` varchar(255),
    PRIMARY KEY (`id`)
)

tag中定义多种内容，中间打;号就行了

4. 创建table

我们可以通过 db.AutoMigrate 和 db.Migrator().CreateTable() 方法来创建table。

AutoMigrate 方法：

使用 db.AutoMigrate 方法是一种自动创建和迁移数据库表的方式。它会根据你的 GORM 模型定义，自动检查数据库表是否存在，如果不存在则创建表，如果表结构有变化则进行迁移。这种方式适用于开发过程中的快速迭代和维护数据库结构的情况。

示例：

// 自动创建和迁移表
err := db.AutoMigrate(&Student{})
// 这里的db就是上述gorm.open的db哈
if err != nil {
    panic("创建/迁移表格失败, error = " + err.Error())
}

Migrator().CreateTable 方法：

使用 db.Migrator().CreateTable 方法是一种手动创建数据库表的方式。你需要显式地指定要创建的表，它不会检查是否已经存在，而是直接创建表。这种方式适用于在特定情况下需要手动控制表创建过程的情况。

示例：

// 手动创建表
err := db.Migrator().CreateTable(&Student{})
if err != nil {
    panic("创建表格失败, error = " + err.Error())
}

区别总结：

  • AutoMigrate 方法自动根据模型定义创建和迁移表，适用于自动化和快速迭代。
  • Migrator().CreateTable 方法手动创建表，适用于需要手动控制创建过程的情况。

在实际应用中，你可以根据项目需求选择合适的方法。通常情况下，开发和调试阶段可能更适合使用 AutoMigrate 方法，而特定场景下的手动控制可能需要使用 Migrator().CreateTable 方法。

5. 增

以下列结构体为例：

type Student struct {
	ID                int
	Name              string
	Age               int
	ExternalCharacter string `gorm:"column:externalCharacter; size:255"`
}

func (s *Student) TableName() string {
	return "student"
}
5.1. db.Create(结构体对象)
lisi := Student{2, "lisi", 18, "modest"}
result := db.Create(&lisi)
if result.Error != nil {
    panic("插入字段失败, error = " + result.Error.Error())
}
fmt.Println(result.RowsAffected) // 返回影响的行数 1

等于INSERT INTO student (name,age,externalCharacter,id) VALUES ('lisi',18,'modest',2)

当然也可以同时增添多个字段

例如：

students := []Student{
    {ID: 3, Name: "wangwu", Age: 20, ExternalCharacter: "generous"},
    {ID: 4, Name: "xuliu", Age: 21, ExternalCharacter: "liberal"},
}
result := db.Create(&students)
if result.Error != nil {
    panic("增加字段失败")
}
fmt.Println(result.RowsAffected) // 返回影响的行数 2

等于INSERT INTOstudent (name,age,externalCharacter,id) VALUES ('wangwu',20,'generous',3),('xuliu',21,'liberal',4)

5.2. db.Select(指定字段).Create(结构体对象)
lisi := Student{2, "lisi", 18, "modest"}
result := db.Select("ID", "Name", "Age").Create(&lisi)
if result.Error != nil {
    panic("插入字段失败, error = " + result.Error.Error())
}
fmt.Println(result.RowsAffected) // 返回影响的行数 1

等于INSERT INTO student (name,age,id) VALUES ('lisi',18,2)

5.3. db.Omit(忽略字段).Create(结构体对象)
lisi := Student{2, "lisi", 18, "modest"}
result := db.Omit("ExternalCharacter").Create(&lisi)
if result.Error != nil {
    panic("插入字段失败, error = " + result.Error.Error())
}
fmt.Println(result.RowsAffected) // 返回影响的行数 1

也等于INSERT INTO student (name,age,id) VALUES ('lisi',18,2)

5.4. 原生sql语句
lisi := Student{2, "lisi", 18, "modest"}
result := db.Exec("INSERT INTO `student` (`name`,`age`,`externalCharacter`,`id`) VALUES ('lisi',18,'modest',2)")
if result.Error != nil {
    panic("插入字段失败, error = " + result.Error.Error())
}
fmt.Println(result.RowsAffected) // 返回影响的行数 1
6. 查

之后所有的操作都是基于我的这份表实现的。

我的表

我现在的表如下：

在这里插入图片描述

6.1 where

我们这里使用where 函数 设置条件

func (db *DB) Where(query interface{}, args ...interface{}) (tx *DB)

参数说明:

参数名说明
querysql语句的where子句, where子句中使用问号(?)代替参数值，则表示通过args参数绑定参数
argswhere子句绑定的参数，可以绑定多个参数

例如db.Where("id in (?)", []int{1,2,3,4})

后面的 select、having 语句这些 query 的也同样适用

6.2 Take

取走第一条查询信息

s1 := Student{}
db.Where("age = 18").Take(&s1)
fmt.Println(s1)

这里我们是先创建了一个结构体对象，查询的结果直接赋予了该对象

输出：

{1 zhangsan 18 humble}

等于：

 SELECT * FROM `student` WHERE age = 18 LIMIT 1

注意这个limit 1，我这里有两个age = 18的，但是take只取一个，一般是第一个

6.3 First

根据主键正序排序后，查询的第一条数据

s1 := Student{}
db.Where("age = 18").First(&s1)
fmt.Println(s1)

输出：

{1 zhangsan 18 humble}

等于：

SELECT * FROM `student` WHERE age = 18 ORDER BY `student`.`id` LIMIT 1
6.4 Last

根据主键倒序排序后，查询最后一条记录

s1 := Student{}
db.Where("age = 18").Last(&s1)
fmt.Println(s1)

输出：

{5 feixin 18 frantic}

等于：

 SELECT * FROM `student` WHERE age = 18 ORDER BY `student`.`id` DESC LIMIT 1
6.5 Find

这里就不是查询一条记录了，可以查询多条记录

这里因为多条记录，一个结构体对象咱也装不完，所以需要改成使用结构体切片(咱也不知道会查出多少记录)

还有一点就是find如果没有找到记录是不会报err的，但是take、first、last会，因为他们都要取走一条数据。

s1 := []Student{}
db.Where("age = 18").Find(&s1)
fmt.Println(s1)

输出：

[{1 zhangsan 18 humble} {5 feixin 18 frantic}]

等于：

SELECT * FROM `student` WHERE age = 18

再举一个使用where args的例子

s1 := []Student{}
db.Where("id in (?)", []int{1, 2, 3, 4}).Find(&s1)
fmt.Println(s1)

输出：

[{1 zhangsan 18 humble} {2 lisi 19 modest} {3 wangwu 20 generous} {4 xuliu 21 liberal}]

等于：

SELECT * FROM `student` WHERE id in (1,2,3,4)
6.6 Pluck

查询一列的值

这个函数返回切片类型，同时需要一个模型Model，就是我们之前定义的结构体模型

col := []string{}
db.Model(&Student{}).Pluck("ExternalCharacter", &col)
for _, i := range col {
    fmt.Println(i)
}

输出：

humble
modest
generous
liberal
frantic

等于：

SELECT `externalCharacter` FROM `student`

关于这个model其实之前的所有操作都可以去写成这个model形式，不过可以省略，在这里就不行了因为你这里没有任何有关student结构体的信息，它甚至都不知道你是哪一个表，那肯定就查找不了咯，所以这里要写这个model。

比如之前的db.Where("age = 18").Find(&s1) 也可以写成

db.Model(&Student{}).Where("age = 18").Find(&s1)

然后这里如果不使用字符串切片，使用结构体student切片的话，就可以不使用model，每一个student对象中没在查找范围的值会变成默认值，也就是int 变 0， string 变 空值。

例如：

col := []Student{}
db.Pluck("ExternalCharacter", &col)
fmt.Println(col)

输出：

[{0  0 humble} {0  0 modest} {0  0 generous} {0  0 liberal} {0  0 frantic}]

等于：

 SELECT `ExternalCharacter` FROM `student`

所以，model的作用 ok 了吗 😝

6.7 Select

Pluck是 一列，那如果我需要多列信息呢？select来帮忙

例如，我想要查询 name 和 age 两列

result := []Student{}
err = db.Select("Age", "Name").Find(&result).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
for _, i := range result {
    fmt.Println(i.Name, i.Age)
}

之的代码没有加err，汗，懒得加了，反正err是这样加😉

输出：

zhangsan 18
lisi 19
wangwu 20
xuliu 21
feixin 18

等于：

SELECT `age`,`name` FROM `student`

select 中也可以使用mysql中的聚集函数

以 avg 为例：

var averAge float32
err = db.Model(&Student{}).Select("avg(age)").Pluck("age", &averAge).Error
if err != nil{
    panic("查询失败, error = " + err.Error())
}
fmt.Println(averAge)

输出：

19.2

等于：

SELECT avg(age) FROM `student`

使用方法和mysql中差不多，具体看官方文档哈

6.8 Order

看单词儿也大概知道了，是排序用的，可以将搜索结果进行排序

例如我按年龄排序：

result := []Student{}
err = db.Order("age asc").Select("Age", "Name").Find(&result).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
for _, i := range result {
    fmt.Println(i.Name, i.Age)
}

这其实就是之前那个加了一个order

输出：

zhangsan 18
feixin 18
lisi 19
wangwu 20
xuliu 21

等于:

 SELECT `age`,`name` FROM `student` ORDER BY age asc
6.9 Limit

可以限制查找条数，比如上面这个，如果想要只找出前三条的话，可以这样写：

result := []Student{}
err = db.Limit(3).Order("age asc").Select("Age", "Name").Find(&result).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
for _, i := range result {
    fmt.Println(i.Name, i.Age)
}

输出：

zhangsan 18
feixin 18
lisi 19

等于：

SELECT `age`,`name` FROM `student` ORDER BY age asc LIMIT 3
6.10 Offset

这个可以过滤掉前几个，还是以上面的为例，如果我想不要zhangsan 和 feixin，取后面三个，那可以这样写:

result := []Student{}
err = db.Offset(2).Limit(3).Order("age asc").Select("Age", "Name").Find(&result).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
for _, i := range result {
    fmt.Println(i.Name, i.Age)
}

输出：

lisi 19
wangwu 20
xuliu 21

等于：

SELECT `age`,`name` FROM `student` ORDER BY age asc LIMIT 3 OFFSET 2

有没有一种反复套娃的赶脚，是这样的没错。🤔

6.11 Count

这个就是返回查询相对应了多少条行数，比如我的表里有两个18岁的小伙子，查查他们的

var count int64
err = db.Model(&Student{}).Where("age = 18").Count(&count).Error
// 这里记得where要写在count前面
if err != nil {
    panic("查询失败, error = " + err.Error())
}
fmt.Println(count)

输出：

2

等于：

SELECT count(*) FROM `student` WHERE age = 18
6.12 Group 与 Having

Group 和 Having 一般联合使用，和sql中也是一样的，因为where 没法对聚合函数进行操作

在 GORM 中，使用 Group 函数时，通常需要搭配 Select 函数一起使用，以指定你希望在分组操作中选择的字段。这是因为在 SQL 查询中，使用 GROUP BY 进行分组时，通常需要明确指定分组后所需的字段。

所以Group, Having , Select 三者一般一起使用。

简而言之，就是Select 用了聚集函数，然后Group 分组，再用Having 进行筛选

比如我现在要对我的表中的各个 age 的人数进行统计，首先我的表中18的有两人，19,20,21的各一人

type Result struct {
    Age     int
    Numbers int
}
var results []Result
err = db.Model(&Student{}).Select("age, count(*) as numbers").
    Group("age").Having("numbers > 0").Find(&results).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
fmt.Println(results)

这里我是定义了一个Result 结构体存储结果， count(*) as numbers 是计算这一列的数目，并取一个别名为numbers， 这里所有这些都要用引号括起来，因为实际上他就是要转化为sql语句（可以仔细对照一下 下文中的等于啥sql语句）。最后老方法用Find 取结果并赋值给了results， 注意这里赋值也是映射赋值，你结构体里面的字段名一定要大写。

输出：

[{18 2} {19 1} {20 1} {21 1}]

等于：

SELECT age, count(*) as numbers FROM `student` GROUP BY `age` HAVING numbers > 0
6.13 原生sql语句

就是上面的例子，如果使用sql语句的话，也可以这样写

type Result struct {
    Age     int
    Numbers int
}
var results []Result
sql := " SELECT age, count(*) as numbers FROM `student` GROUP BY `age` HAVING numbers > 0"
err = db.Raw(sql).Find(&results).Error // 这个Find 应该要换成 Scan
if err != nil {
    panic("查询失败, error = " + err.Error())
}
fmt.Println(results)

之前在增中 使用的 Exec 方法是只返回语句执行情况，不会返回结果集，这里需要查询结果，我们改用Raw

结果是一样的，就不表了，这里说一下 Find 和Scan

  1. Find 方法： Find 方法用于从数据库中查询数据并将结果映射到指定的结构体切片中。它适用于正常的 GORM 查询操作，根据条件从数据库中检索数据并进行映射。
  2. Scan 方法： Scan 方法用于将结果扫描到指定的结构体切片中，而不需要进行查询操作。它通常用于执行原生 SQL 查询，并将查询结果映射到结构体中。

意思就是Find和Scan差不多，但是这里我在使用原生sql语句，所以应该使用Scan

7. 删

删就很简单了，我们可以先查出来再删，也可以根据主键删除

还是这张表

在这里插入图片描述

现在我要把这个frantic的家伙给删除

可以先找到他

s := Student{}
err = db.Where("externalCharacter = 'frantic'").Find(&s).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
err = db.Delete(s).Error
if err != nil {
    panic("删除失败, error = " + err.Error())
}

如果知道主键的话也可以直接

err = db.Delete(&Student{}, 5).Error
if err != nil {
    panic("删除失败, error = " + err.Error())
}

等于：

DELETE FROM `student` WHERE `student`.`id` = 5
8. 改

还是这张表

在这里插入图片描述

8.1 Save

我们可以直接对结构体的字段进行修改然后进行save 操作映射到mysql中同步更改

比如我这里把 feixin 的 age 改为 19

s := Student{}
err = db.Where("id = ?", 5).Find(&s).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
s.Age = 19
err = db.Save(&s).Error
if err != nil {
    panic("更新失败, error = " + err.Error())
}

等于：

UPDATE `student` SET `name`='feixin',`age`=19,`externalCharacter`='frantic' WHERE `id` = 5
8.2 Update

上面的也可以这样写

s := Student{}
err = db.Where("id = ?", 5).Find(&s).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
err = db.Model(&s).Update("age", 19).Error
if err != nil {
    panic("更新失败, error = " + err.Error())
}

等于：

UPDATE `student` SET `age`=19 WHERE `id` = 5
8.3 Updates

可以更新多列值

s := Student{}
err = db.Where("id = ?", 5).Find(&s).Error
if err != nil {
    panic("查询失败, error = " + err.Error())
}
err = db.Model(&s).Updates(Student{
    Name: "feixin",
    Age:  18,
}).Error
if err != nil {
    panic("更新失败, error = " + err.Error())
}

等于：

UPDATE `student` SET `name`='feixin',`age`=18 WHERE `id` = 5
8.4 表达式

比如我把所有人的年龄都加1

err = db.Model(&Student{}).Where("age > ?", 0).Update("age", gorm.Expr("age + ?", 1)).Error
if err != nil {
    panic("更新失败, error = " + err.Error())
}

等于：

UPDATE `student` SET `age`=age + 1 WHERE age > 0

在 GORM 中，使用 Update 方法时，需要提供一个条件来指定要更新哪些记录。所以这里需要写where 语句，不然会报err，之前的没有没有使用是因为Model 里填的是结构体对象，实际上就算已经指定了条件。、

当然，如果不想使用where的话也是有办法的，我们可以启用 AllowGlobalUpdate 模式

err = db.Session(&gorm.Session{AllowGlobalUpdate: true}).Model(&Student{}).Update("age", gorm.Expr("age + ?", 1)).Error
if err != nil {
    panic("更新失败, error = " + err.Error())
}

等于：

UPDATE `student` SET `age`=age + 1
paintstar
关注
  • 3
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
golang入门笔记—Gorm
qq_43716830的博客
04-28 3149
Gorm是go语言编写的一个ORM框架，是中国人开发的框架（自豪） 偷懒不写sql语句数据库操作神器 ORM的优缺点： 优点： 提高开发效率 缺点： 牺牲执行功能 牺牲灵活性 弱化SQL能力 Gorm基本操作 package main import ( "fmt" "github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/mysql" ) type UserInfo struct { Id uint Name stri
Gorm存在时更新，不存在时创建
sunriseYJP的博客
01-30 3356
Gorm存在时更新，不存在时创建
Go GORM实战(一) | 简单的增删改查
qq_39335595的博客
05-15 398
GORM是一个非常优秀的Golang数据库ORM库，支持MySQL, PostgreSQL, SQlite, SQL Server等数据库。
【GORM】使用GORM连接各种数据库（2022）
大河之犬的博客
05-29 5279
gorm是一个使用Go语言编写的ORM框架。它文档齐全，对开发者友好，支持主流数据库。
个人技术总结——Gorm框架的多表联合查询
m0_51671161的博客
06-06 3051
Gorm框架可以进行多表联合查询，通过多表联合查询可以通过一条sql语句即可完成对数据库多表数据的获取，而不需要执行多条sql语句对数据库进行多次访问，从而加快了数据的处理速度。通俗来说，对于表A和表B，left join返回包括表A中的所有记录和表B中联结字段相等的记录；下面是Gorm框架实现多表查询的具体步骤。关键点在于要利用Joins()函数来选择连接查询的表，并且这里的函数参数要根据刚刚的Model设计中的命名来选择，比如在Comment中我们要查询的是Author字段，就传入“Author”。
23.4.22 Go学习日记
BigCanda的博客
04-22 96
分为整形(int8,int16,int32即int,int64,uint8,uint16,uint32,uint64)、浮点型(float32)、双精度float64)、字符串(string)、布尔(bool)、字节(byte,等同于int8)、数组(包括整形、浮点型、字符型)、指针、结构体var (a int8b int16c int32long int64str stringbt byte// 结构体在一定程度上代替了对象// 用于数据库表的创建，方便模型定义。
【字节跳动青训营】后端笔记整理-4 | Go框架三件套之GORM的使用
wyd_333的博客
08-27 1893
GORM 是 Go 语言中一个强大的 ORM 库（ORM 即对象关系映射，是一种程序设计技术，用于将不同类型的数据进行转换从而实现面向对象编程语言与数据库之间的交互），用于简化数据库操作。
golang gorm增删改查db.Model db.Where db.Table
12-14
1. 创建 ...可以在gorm tag中定义默认值，然后插入SQL将忽略具有默认值的这些字段，并且其值为空，并且在将记录插入数据库后，gorm将从数据库加载这些字段的值。 type Animal struct { ID int64 Nam
gorm golang 并发连接数据库报错的解决方法
01-03
底层报错 error：cannot assign requested address 原因 并发场景下 client 频繁请求...以上这篇gorm golang 并发连接数据库报错的解决方法就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支
基于Gin+Gorm+Mysql搭建的简易增删改查api接口
03-15
基于Gin+Gorm+Mysql搭建的简易增删改查api接口
golang使用json格式实现增删查改的实现示例
09-16
在Golang中，使用JSON格式实现增删查改是一种轻量级的数据持久化方式，尤其适合小型项目或不需要复杂数据库管理的场景。本文将详细探讨如何利用Golang的JSON库来处理这些操作。 首先，JSON（JavaScript Object ...
Go GORM介绍
最新发布
qq_39335595的博客
05-22 953
在 GORM 中，模型通常由 Go 结构体表示，每一个模型对应数据库中的一个表。gorm.ModelAge uint在上面的代码中，gorm.Model是一个包含了 ID, CreatedAt, UpdatedAt, DeletedAt 字段的基础模型。我们在此基础上添加了自定义字段(Name, Age, Active)。
使用 GORM（Go 的 ORM 库）实现增删改查 ｜ 青训
2301_79125431的博客
08-20 61
知识点：单调栈我们要找到每个元素后面的更大元素，我们可以通过使用单调栈的思想来解决，对于这类下一个更大元素的题目，都可以使用单调栈来解决，我们维护一个栈，若栈顶。一起昨天改分析的逻辑，改完之后发现不报结果了，下午又重新梳理框架，把上午改的东西又做了修改，结果发现改错了，上午写的没问题，又改回去。题目考察的知识点考察哈希表的应用题目解答方法的文字分析与前两道题目一样，直接复用代码就可以通过，不一样的是这次找出现两次的值。让我介绍实习最主要的工作，我说了其中一个，其他的工作也。本题解析所用的编程语。
golang之gorm库连接mysql操作
专注于Python编程技术的分享与交流，致力于帮助开发者提升编程技能，解决实际问题，探索Python的无限可能。
10-19 3057
GORM 是 Go 语言的一个对象关系映射（ORM）库，它提供了一种简单、简洁的方式来与数据库交互，通过让开发人员使用 Go 结构体来代替直接编写 SQL 查询。GORM 支持多个数据库后端，例如 MySQL、PostgreSQL、SQLite 和 SQL Server，并提供自动表创建、模式迁移以及数据库表之间的关联等功能。使用 GORM，开发人员可以将模型定义为 Go 结构体，并使用 Create、Save、Update 和 Delete 等方法来与数据库交互。
go学习 --- go对mysql的增删改查
qq_46093575的博客
02-09 979
一、go实现对数据库的增删改查 package main import ( "database/sql" "fmt" _"github.com/go-sql-driver/mysql" //初始化 ) //定义一个全局变量 var db *sql.DB //定义初始化数据库的函数 func initDB()(err error) { dsn := "root:123456@tcp(127.0.0.1:3306)/db02?charset=utf8mb4&parseTime=True
Go-GORM操作mysql
qq_52785898的博客
05-18 3740
go使用gorm操作mysql，并进行日志的记录
go学习 --- gorm使用
qq_46093575的博客
01-25 1966
一、下载gorm包 下载命令:go get -u github/jinzhu/gorm 二、连接数据库进行增删改查 package main import ( "fmt" "github.com/jinzhu/gorm" _"github.com/jinzhu/gorm/dialects/mysql" ) //创建结构体与数据表映射 type User struct { ID uint Name string Gender string Hobby string } func
关于 gorm AutoMigrate 不自动创建字段的解决方案
白蚁的代码世界
07-29 7471
前言 进来转战Go,在使用gorm时使用AutoMigrate()自动创建表的时候,发现表可以创建,字段死活创建不出来,百度也搜不到任何有用的信息,直到我翻了gorm的文档,发现他的代码是这样的 type User struct { gorm.Model Name string Age sql.NullInt64 Birthday *time.Time Email string `gorm:"type:varchar(100
Gorm—Go语言数据库框架
追求幸福，探索未知的博客
07-30 6003
Go语言最流行的数据库ORM【对象关系映射】框架。
写一个gorm连接mysql增删改查示例，并给出注释
05-19
以下是一个使用 GORM 连接 MySQL 并进行增删改查的示例代码，已经注释说明每个步骤的作用。 ```go package main import ( "fmt" "gorm.io/driver/mysql" // 导入 MySQL 驱动 "gorm.io/gorm" // 导入 GORM ) type User struct { // 定义 User 结构体 gorm.Model // 继承 GORM 模型结构体，包含 ID、CreatedAt、UpdatedAt、DeletedAt 字段 Name string Age int } func main() { // 1. 连接 MySQL 数据库 dsn := "root:password@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local" db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) if err != nil { panic("failed to connect database") } defer db.Close() // 程序结束时关闭数据库连接 // 2. 自动迁移数据表 db.AutoMigrate(&User{}) // 自动创建数据表 // 3. 插入数据 user := User{Name: "Tom", Age: 18} result := db.Create(&user) // 插入数据 if result.Error != nil { panic("failed to create user") } fmt.Println(user.ID) // 输出新插入数据的 ID // 4. 查询数据 var users []User db.Find(&users) // 查询所有数据 fmt.Println(users) var user2 User db.First(&user2, 1) // 根据主键查询单条数据 fmt.Println(user2) var user3 User db.Where("name = ?", "Tom").First(&user3) // 根据条件查询单条数据 fmt.Println(user3) // 5. 更新数据 db.Model(&user).Update("Age", 20) // 更新数据 fmt.Println(user) // 6. 删除数据 db.Delete(&user) // 删除数据 } ``` 注意，这里的 `dsn` 是连接 MySQL 数据库的字符串，其中包含了用户名、密码、主机地址、端口号、数据库名等信息，需要根据实际情况进行修改。同时，这里使用了 GORM 的链式查询语法，通过 `db.Find()` 和 `db.Where()` 方法来查询数据，可以根据实际需求进行修改。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值