[golang gin框架] 7.Gin GORM增删改查以及查询语句详解

已于 2023-10-18 11:26:08 修改
阅读量2.6k 收藏 7
点赞数 1
分类专栏： golang # gin框架开发 文章标签： golang gin gin gorm
于 2023-03-26 21:20:44 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhoupenghui168/article/details/129784764
版权
这篇文章详细介绍了如何在Gin框架中使用GORM库进行数据库的基本操作，包括添加、查找、修改和删除数据。GORM是一个用于Go语言的ORM库，简化了数据库交互。示例代码展示了如何定义模型、执行查询、条件过滤、排序、分页以及使用预加载等功能。
摘要由CSDN通过智能技术生成

1.GORM CURD

找到要操作数据库表的控制器，然后引入 models 模块

models/user.go

package models

type User struct { // 结构体首字母大写, 和数据库表名对应, 默认访问数据表users, 可以设置访问数据表的方法
    Id  int
    Username string
    Age int
    Email string
    AddTime int // 大驼峰命名
}

//配置数据库操作的表名称
func (User) TableName() string {
    return "user"
}

(1).添加数据

增加成功后会返回刚才增加的记录 
//添加数据
func (con UserController) Add(c *gin.Context) {
    user := &models.User{
        Username: "张三",
        Age: 12,
        Email: "test@qq.com",
        AddTime: int(models.GetUnix()),
    }
    err := models.DB.Create(user).Error // 通过数据的指针来创建
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(user)
    c.String(200, "增加数据成功")
}

更多添加语句见文档:创建 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

(2).查找

func (con UserController) Index(c *gin.Context) {
    //查找全部
    userList := []models.User{}
    //查询所有用户,把结果保存到userList切片中
    models.DB.Find(&userList)
    c.JSON(http.StatusOK, gin.H{
        "result": userList,
    })

    //条件查询
    //查询age大于30的用户
    //查询数据库
    userList := []models.User{}
    models.DB.Where("age > ?", 30).Find(&userList)
    c.JSON(http.StatusOK, gin.H{
        "result": userList,
    })
}

更多查询语句：查询 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

(3).修改

func (con UserController) Edit(c *gin.Context) {
    //查询id等于5的字段
    user := models.User{Id: 5}
    models.DB.Find(&user)
    c.JSON(200, gin.H{
        "user": user,
    })
    //更新所有数据
    user.Username = "你好"
    user.Age = 111
    models.DB.Save(&user)

    //更新单个列
    user1 := models.User{}
    models.DB.Model(&user1).Where("id = ?", 9).Update("username", "大")

    //一般情况的更新
    user2 := models.User{}
    models.DB.Where("id = ?", 1).Find(&user2)
    user2.Username = "好"
    user2.Age = 31
    models.DB.Save(&user2)
}

更多修改的方法参考：更新 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

(4).删除

//删除数据
func (conn UserController) Delete(c *gin.Context) {
    user := models.User{Id: 1}
    models.DB.Delete(&user)

    //删除数据
    user1 := models.User{}
    models.DB.Where("Age = ?", 31).Delete(&user1)
}

更多删除的方法参考:删除 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

2.GORM 查询语句详解

(1).查询全部数据

    //查询全部数据
    list := []models.Nav{}
    //把结果保存到list切片中
    models.DB.Find(&list)
    c.JSON(http.StatusOK, gin.H{
        "result": list,
    })

(2).查询一条数据

    //查询一条数据
    nav := models.Nav{Id: 21}
    models.DB.Find(&nav)
    c.JSON(http.StatusOK, gin.H{
        "result": nav,
    })
    nav1 := models.Nav{}
    models.DB.First(&nav1, "21")
    c.JSON(http.StatusOK, gin.H{
        "result": nav1,
    })

    nav2 := models.Nav{}
    models.DB.Model(models.Nav{Id: 21}).First(&nav2)
    c.JSON(http.StatusOK, gin.H{
        "result": nav2,
    })

(3).Where

=,<,>,<=,>=,!=,IS NOT NULL,IS NULL,BETWEEN AND,NOT BETWEEN AND,IN,OR,AND,NOT,LIKE查询 
    查询id>3的数据
    nav := []models.Nav{}
    models.DB.Where("id > ?", 3).Find(&nav)
    c.JSON(http.StatusOK, gin.H{
        "result": nav,
    })
    
    //查询id>3 并且 id < 9 的数据
    nav1 := []models.Nav{}
    models.DB.Where("id > ? and id < ?", 3, 9).Find(&nav1)
    c.JSON(http.StatusOK, gin.H{
        "result": nav1,
    })
    //查询id=3,5,6的数据
    nav2 := []models.Nav{}
    models.DB.Where("id in ?", []int{3, 5, 6}).Find(&nav2)
    c.JSON(http.StatusOK, gin.H{
        "result": nav2,
    })
    
    //查询标题包含 '会'的内容
    nav3 := []models.Nav{}
    models.DB.Where("title like ?", "%会%").Find(&nav3)
    c.JSON(http.StatusOK, gin.H{
        "result": nav3,
    })
    
    //查询id>3 并且 id < 9 的数据,使用between and
    nav4 := []models.Nav{}
    models.DB.Where("id between ? and ?", 3, 9).Find(&nav4)
    c.JSON(http.StatusOK, gin.H{
        "result": nav4,
    })
    //查询id=2或者iD=3的数据
    //方法一
    nav5 := []models.Nav{}
    models.DB.Where("id = ? or id =  ?", 3, 9).Find(&nav5)
    c.JSON(http.StatusOK, gin.H{
        "result": nav5,
    })
    //方法二
    nav6 := []models.Nav{}
    models.DB.Where("id = ?", 2).Or("id = ?", 3).Find(&nav6)
    c.JSON(http.StatusOK, gin.H{
        "result": nav6,
    })

(4).选择字段查询

    //使用select返回指定的字段, 使用结构体时,没有的数据会默认为0或""
    nav7 := []models.Nav{}
    models.DB.Select("title", "id").Where("id = ?", 2).Or("id = ?", 3).Find(&nav7)
    c.JSON(http.StatusOK, gin.H{
        "result": nav7,
    })

(5).排序 Limit 、Offset

    //order排序, limit, Offset
    nav8 := []models.Nav{}
    models.DB.Order("id desc").Find(&nav8)
    c.JSON(http.StatusOK, gin.H{
        "result": nav8,
    })
    
    nav9 := []models.Nav{}
    models.DB.Order("id desc").Limit(3).Find(&nav9)
    c.JSON(http.StatusOK, gin.H{
        "result": nav9,
    })
    //分页
    nav10 := []models.Nav{}
    models.DB.Order("id desc").Offset(2).Limit(3).Find(&nav10)
    c.JSON(http.StatusOK, gin.H{
        "result": nav10,
    })

(6).count计数

    nav11 := []models.Nav{}
    var num int64
    models.DB.Where("id > ? and id < ?", 3, 9).Find(&nav11).Count(&num)
    c.JSON(http.StatusOK, gin.H{
        "result": num,
    })

(7).Distinct

从模型中选择不相同的值 
nav := []models.Nav{}
models.DB.Distinct("title").Order("id desc").Find(&nav)
c.JSON(200, gin.H{ 
    "nav": nav,
 })
//SELECT DISTINCT `title` FROM `nav` ORDER BY id desc

(8).Scan

将结果扫描到结构中的方法与我们使用find的方法类似 
type Result struct {
    Name string
    Age int
}
var result Result
models.DB.Table("users").Select("name", "age").Where("name = ?", "Antonio").Scan(&result)
// 原生 SQL
models.DB.Raw("SELECT name, age FROM users WHERE name = ?", "Antonio").Scan(&result)
var result []models.User
models.DB.Raw("SELECT * FROM user").Scan(&result)
fmt.Println(result)

(9).Joins

查询内联 
type result struct {
  Name  string
  Email string
}

db.Model(&User{}).Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})
// SELECT users.name, emails.email FROM `users` left join emails on emails.user_id = users.id

rows, err := db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Rows()
for rows.Next() {
  ...
}

db.Table("users").Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)

// multiple joins with parameter
db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?", "jinzhu@example.org").Joins("JOIN credit_cards ON credit_cards.user_id = users.id").Where("credit_cards.number = ?", "411111111111").Find(&user)
//Joins 预加载
You can use Joins eager loading associations with a single SQL, for example:

db.Joins("Company").Find(&users)
// SELECT `users`.`id`,`users`.`name`,`users`.`age`,`Company`.`id` AS `Company__id`,`Company`.`name` AS `Company__name` FROM `users` LEFT JOIN `companies` AS `Company` ON `users`.`company_id` = `Company`.`id`;

// inner join
db.InnerJoins("Company").Find(&users)
// SELECT `users`.`id`,`users`.`name`,`users`.`age`,`Company`.`id` AS `Company__id`,`Company`.`name` AS `Company__name` FROM `users` INNER JOIN `companies` AS `Company` ON `users`.`company_id` = `Company`.`id`;
Join with conditions

db.Joins("Company", db.Where(&Company{Alive: true})).Find(&users)
// SELECT `users`.`id`,`users`.`name`,`users`.`age`,`Company`.`id` AS `Company__id`,`Company`.`name` AS `Company__name` FROM `users` LEFT JOIN `companies` AS `Company` ON `users`.`company_id` = `Company`.`id` AND `Company`.`alive` = true;
For more details, please refer to Preloading (Eager Loading).

Joins 一个衍生表
You can also use Joins to join a derived table.

type User struct {
    Id  int
    Age int
}

type Order struct {
    UserId     int
    FinishedAt *time.Time
}

query := db.Table("order").Select("MAX(order.finished_at) as latest").Joins("left join user user on order.user_id = user.id").Where("user.age > ?", 18).Group("order.user_id")
db.Model(&Order{}).Joins("join (?) q on order.finished_at = q.latest", query).Scan(&results)
// SELECT `order`.`user_id`,`order`.`finished_at` FROM `order` join (SELECT MAX(order.finished_at) as latest FROM `order` left join user user on order.user_id = user.id WHERE user.age > 18 GROUP BY `order`.`user_id`) q on order.finished_at = q.latest

(10).查看执行的失去了

package models

//gorm文档: https://gorm.io/zh_CN/docs/index.html
//连接数据库核心代码

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

//全局使用DB,就需要把DB定义成公有的
var DB *gorm.DB
var err error

//自动初始化数据库
func init()  {
    // 参考 https://github.com/go-sql-driver/mysql#dsn-data-source-name 获取详情
    dsn := "root:123456@tcp(127.0.0.1:3306)/gin?charset=utf8mb4&parseTime=True&loc=Local"
    DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
    //查看执行的sql
    DB.Debug()
    if err != nil {
        fmt.Println(err)
    }
}

更多查询语句:查询 | GORM - The fantastic ORM library for Golang, aims to be developer friendly.

[上一节]6.Gin GORM简介以及安装

[下一节][golang gin框架] 8.Gin GORM原生 SQL以及表关联查询_gorm获取sql

zhoupenghui168
关注
  • 1
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Gin+Gorm开发Golang API快速开发脚手架-Golang开发
05-26
Gin+Gorm开发Golang API快速开发脚手架 Singo Singo: Simple Single Golang Web Service go-crud正式改名为Singo! 使用Singo开发Web服务: 用最简单的架构，实现够用的框架，服务海量用户 ... Singo文档 ...
【Go后台开发第一课】实现go语言下gin框架与gorm的数据库增删改查的操作
yunyin_link的博客
03-05 3244
学习目标： 实现go语言下gin框架与gorm的数据库增删改查的操作 开发工具： Win10 + goland 正式操作： 1、goLand下创建新功能 ginGormTestProject 试运行一下helloworld package main import "fmt" func main() { fmt.Println("Hello World") } 2、开始使用gin框架，让他成为一个web应用 package main import “github.com/g
Go语言Gin框架+Gorm实战CRUD
ecloud_developer的博客
12-21 1407
Gin 和 Gorm 是 Go 编程语言中流行的开源库。但是，它们服务于不同的目的，通常在 web 开发项目中一起使用。 Gin 是一个用于构建 HTTP 服务器的 web 框架。它提供了一个简单易用的 API，用于处理 HTTP 请求和响应、路由、中间件和其他常见的 web 应用程序所需的功能。它以其高性能和简约为特点，提供了轻量级和灵活的解决方案来构建 web 服务器。 Gorm 是 Go 的一个 ORM（对象关系映射）库。
gorm多表联合查询 Joins方法 LEFT JOIN , RIGHT JOIN , INNER JOIN， FULL JOIN 使用总结
最新发布
07-15 755
当然我们这里要说的使用方式是官方示例里面没有的，有的我们就不重复废话了。从上面的方法定义我们可以看到，这个Joins的第一个参数query string 他就是一个查询字符串， 第二个参数是可变参数， 从这个参数定义就可以看出，这里的第一个参数query 就是我们需要进行多表链接的查询参数，这里的查询参数可以是任何的SQL支持的链接查询语句，如LEFT JOIN, RIGHT JOIN , INNER JOIN， FULL JOIN等。
gin框架学习-GORM框架进阶之CRUD接口(数据库增删改查操作)
林钟一的博客
07-12 3958
gin框架学习-GORM框架CRUD接口（实现数据库的增删改查操作）
Go语言gin框架+gorm框架项目：后端配置swagger
pyscl01的博客
05-08 2207
Go语言gin框架+gorm框架项目：后端配置swagger的详细步骤
go语言使用Gin框架链接数据库
jakelihua
05-19 3241
本文讲解如何使用go语言链接数据库以下是一些用Gin框架链接数据库的步骤：假设您选择的数据库是MySQL，首先需要在系统中安装相应的MySQL数据库，并创建一个名为“testdb”的数据库。输入下载之后可以看见的是，在go.sum里面就有了相关的包。
[golang gin框架] 44.Gin商城项目-微服务实战之后台Rbac微服务之权限的增删改查微服务
zhoupenghui168的博客
07-30 1403
Gin商城项目-微服务实战之后台Rbac微服务之权限的增删改查微服务
Golang基础语法和gorm以及gin总汇精简版10000字
12-01
资源内包含了golang的基础语法例如匿名函数回调函数channel结构体接收者以及面向对象编程方面的知识，gorm基础的增删改查和部分进阶以及gin的介绍和使用方式以及有例子说明供参考。此资源为个人所撰写。
Go语言中的gin框架之GET/POST请求参数接收传值（五）
06-15
在Go语言中，Gin框架是一个...总结，Gin框架在处理GET和POST请求参数时提供了多种方法，包括从URL查询字符串、JSON请求体以及Form数据中获取参数。这使得Gin成为构建Web服务的强大工具，特别是在Go语言的生态系统中。
由gin + gorm + jwt + casbin组合实现的RBAC权限管理脚手架Golang-gin-web.zip
11-06
3. 角色与权限管理：通过Gorm操作数据库，进行角色和权限的增删改查。 4. 权限分配：使用Casbin定义策略，例如`user_role`和`role_permission`，并将这些策略应用到用户。 5. 中间件实现：在Gin中编写中间件，检查...
PasteMeGoBackend:PasteMe Go 后端，Golang + Gin + Gorm
05-05
### Gin框架详解 Gin是一个基于Golang的高性能Web框架，它以Martini库为灵感，但提供了更快速的性能。Gin通过中间件链来处理HTTP请求，使得开发过程中路由、错误处理、中间件等功能的设置变得简单易行。例如，你可以...
【Gin】Gin 使用 GORM 操作 MySQL 数据库
徒挽的博客
03-28 3668
GORM 是Golang 的一个 orm 框架。ORM 就是通过实例对象的语法，完成关系数据库的操作的技术，是“对象-关系映射”（Object-Relational Mapping）的缩写。使用 orm 框架可以让我们更方便的操作数据库。
Go+Gin+GORM+Mysql实现最基础的CRUD
m0_73646471的博客
01-10 551
1.准备工作1.准备工作1.安装go的环境2.安装数据库mysql安装后在解压目录下新建ini文件并且拷入：[mysqld]# 设置3306端口port=3306# 设置mysql的安装目录 ----------是你的文件路径-------------# 设置mysql数据库的数据的存放目录 ---------是你的文件路径data文件夹自行创建# 允许最大连接数# 允许连接失败的次数。# 服务端使用的字符集默认为utf8mb4。
使用gin做一个增删改查接口
qq_48565495的博客
04-13 1268
一. 准备工作 1.数据库 2. 需要导入的包 sql包:“database/sql” sql驱动包:"_github.com/go-sql-driver/mysql" gin框架包:“github.com/gin-gonic/gin” http包:“net/http” ![需要加入的包](https://img-blog.csdnimg.cn/20210413114016159.jpg#pic_center 这里的下划线“_”是只使用mysql驱动下的所有init()方法 3.check方法 c
Golang GORM 初始化/增、删、改、查
小楼一夜听春雨，深巷明朝卖杏花
04-12 1691
使用golang的orm框架就是将golang当中的struct，就是结构体和数据库当中的表字段进行一个映射。orm框架主要的作用就是，在go里面就是struct，在java里面其实就是class类，也即是让对象和表产生一个映射关系，我们就不需要操作表了，直接操作对象就行了。当我导入进来不使用的时候，说明包里面init函数是要执行的，其实就是执行里面的init。总而言之就是操作结构体就能够操作数据库，操作结构体，那么表里面的数据其实也就会跟着发生变化。如果导入的包是不使用的，那么在前面加上_，比如。
Go使用Gin+mysql实现增删改查
Harris-H的博客
09-29 2085
Go、mysql
[golang gin框架] 6.Gin GORM简介以及安装
zhoupenghui168的博客
03-26 1801
Gin GORM简介以及安装
Go Web学习笔记（Gin和Gorm）
weixin_51563603的博客
01-28 1532
本人在学长的推荐下，之后就要用Go开发后端啦！之前已经把go的基础语法过了一遍，现在学习Gin和Gorm框架，特此记录一下，也希望对你们有帮助 这里顺便再提供一下Go基础语法的中文官方文档 Gin框架 用go原生的https包写hello world package main import ( "fmt" "net/http" //引用http包 ) func sayHello(w http.ResponseWriter, r *http.Request) { _, _ = fmt.Fprint
用 golang 开发语言和gin、gorm 框架帮我写个后台接口服务，有图片上传功能和用户信息的增删改查，用户信息包括：姓名、性别、头像、描述
06-07
好的，我可以帮您实现这个功能。首先，我需要确认一下您的开发环境是否已经准备好了，包括 Go 编译器和相关的依赖库。 接下来，我将为您提供一个简单的代码示例，用于创建一个 API 服务并实现用户信息的增删改查功能。同时，该示例还包含了图片上传的功能，使用了 Gin 框架和 GORM ORM 库。 以下是示例代码： ```go package main import ( "fmt" "net/http" "os" "github.com/gin-gonic/gin" "github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/mysql" ) type User struct { gorm.Model Name string `json:"name"` Gender string `json:"gender"` Description string `json:"description"` Avatar string `json:"avatar"` } func main() { // 初始化数据库连接 db, err := gorm.Open("mysql", "user:password@tcp(127.0.0.1:3306)/database?charset=utf8mb4&parseTime=True&loc=Local") if err != nil { fmt.Println("database connect error:", err) os.Exit(1) } defer db.Close() // 创建用户表 db.AutoMigrate(&User{}) // 创建 Gin 实例 router := gin.Default() // 添加用户接口 router.POST("/users", func(c *gin.Context) { // 解析请求参数 var user User if err := c.BindJSON(&user); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } // 保存用户信息 if err := db.Create(&user).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, user) }) // 查询用户接口 router.GET("/users/:id", func(c *gin.Context) { // 获取用户 ID id := c.Param("id") // 查询用户信息 var user User if err := db.First(&user, id).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, user) }) // 更新用户接口 router.PUT("/users/:id", func(c *gin.Context) { // 获取用户 ID id := c.Param("id") // 查询用户信息 var user User if err := db.First(&user, id).Error; err != nil { c.JSON(http.StatusNotFound, gin.H{"error": err.Error()}) return } // 解析请求参数 var updateUser User if err := c.BindJSON(&updateUser); err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } // 更新用户信息 user.Name = updateUser.Name user.Gender = updateUser.Gender user.Description = updateUser.Description user.Avatar = updateUser.Avatar if err := db.Save(&user).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, user) }) // 删除用户接口 router.DELETE("/users/:id", func(c *gin.Context) { // 获取用户 ID id := c.Param("id") // 删除用户信息 if err := db.Delete(&User{}, id).Error; err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, gin.H{"message": "delete success"}) }) // 上传图片接口 router.POST("/upload", func(c *gin.Context) { // 从请求中获取文件 file, err := c.FormFile("file") if err != nil { c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) return } // 保存文件到本地 filename := fmt.Sprintf("uploads/%s", file.Filename) if err := c.SaveUploadedFile(file, filename); err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()}) return } c.JSON(http.StatusOK, gin.H{"url": filename}) }) // 启动服务 router.Run(":8080") } ``` 在这个示例中，我们首先定义了一个 User 结构体，包含了我们要存储的用户信息。然后，我们使用 GORM 库创建了一个数据库连接，并在其中创建了一个用户表。 接着，我们使用 Gin 框架创建了四个 API 接口，分别用于添加、查询、更新和删除用户信息。其中，添加、更新和查询用户信息的接口都使用了 BindJSON 方法来解析请求参数，并使用 GORM 库来持久化用户信息到数据库中。 最后，我们还添加了一个用于上传图片的接口，使用了 Gin 框架的 FormFile 方法来获取上传的文件，并使用 SaveUploadedFile 方法将文件保存到本地。 请注意，由于这个示例中的数据库连接字符串中包含了敏感信息，因此在实际使用中，您需要将其替换为您自己的数据库连接字符串。 希望这个示例能够帮助到您，如果您有任何问题或需要进一步的帮助，请随时提出。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值