使用grom操作数据库

最新推荐文章于 2023-09-13 15:42:41 发布
最新推荐文章于 2023-09-13 15:42:41 发布
阅读量1.5k 收藏 2
点赞数 1
分类专栏： golang 文章标签： 数据库 mysql golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_58121644/article/details/129047257
版权

grom官方网站

https://gorm.io

安装grom和mysql驱动

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

测试链接

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

func main() {
  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{})
  if err != nil {
		fmt.Printf("err: %v\n", err)
	}
	fmt.Printf("db: %v\n", db)
}

输出结果表示运行成功

db: &{0xc000116510 <nil> 0 0xc0001c6380 1}

GORM模型定义

GORM 定义一个 gorm.Model 结构体，其包括字段 ID、CreatedAt、UpdatedAt、DeletedAt

// gorm.Model 的定义
type Model struct {
  ID        uint           `gorm:"primaryKey"`
  CreatedAt time.Time
  UpdatedAt time.Time
  DeletedAt gorm.DeletedAt `gorm:"index"`
}

创建模型，根据模型生成数据库表

type User struct {
	gorm.Model   //内嵌gorm.Model
	Name         string
	Age          sql.NullInt64 //零值类型
	Birthday     *time.Time
	Email        string  `gorm:"type:varchar(100);unique_index"`
	Role         string  `gorm:"size:255"`        //设置字段大小为255
	MemberNumber *string `gorm:"unique;not null"` //设置会员号，唯一并且不为空
	Num          int     `gorm:"AUTO_INCREMENT"`  //设置num为自增类型
	Address      string  `gorm:"index:addr"`      //给address字段创建名为addr的索引
	IgnoreMe     int     `gorm:"-"`               //忽略本字段
}

func main() {
	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{})
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}

	db.AutoMigrate(&User{})
}

结构体中属性名的大驼峰对应数据库中下划线分割的字段
结构体的名字的复数对应数据库名字

+---------------+-----------------+------+-----+---------+----------------+
| Field         | Type            | Null | Key | Default | Extra          |
+---------------+-----------------+------+-----+---------+----------------+
| id            | bigint unsigned | NO   | PRI | NULL    | auto_increment |
| created_at    | datetime(3)     | YES  |     | NULL    |                |
| updated_at    | datetime(3)     | YES  |     | NULL    |                |
| deleted_at    | datetime(3)     | YES  | MUL | NULL    |                |
| name          | longtext        | YES  |     | NULL    |                |
| age           | bigint          | YES  |     | NULL    |                |
| birthday      | datetime(3)     | YES  |     | NULL    |                |
| email         | varchar(100)    | YES  |     | NULL    |                |
| role          | varchar(255)    | YES  |     | NULL    |                |
| member_number | varchar(191)    | NO   | UNI | NULL    |                |
| num           | bigint          | YES  |     | NULL    |                |
| address       | varchar(191)    | YES  | MUL | NULL    |                |
+---------------+-----------------+------+-----+---------+----------------+

指定表明

func (User)TableName() string{
	return "user_table"
}

创建表 插入数据

type User struct {
	ID   int64
	Name string
	Age  int64
}

func main() {
	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{})
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}

	//2,把模型与数据库中的表对应起来
	db.AutoMigrate(&User{})

	//3,创建记录
	user := User{Name: "poole", Age: 23}
	db.Create(&user)
}

通过tag设置字段，当该属性为空的时候，将值赋为默认值

type User struct {
	ID   int64
	Name string
	Age  int64 `gorm:"default:20"`
}

注意：对于所有字段的零值，包括0，""，nil 都不会保存到数据库，使用的是他们的默认值，使用指针将避免此情况

type User struct {
	ID   int64
	Name string
	Age  int64 `gorm:"default:20"`
}

结构体中传入的是一个空的指针，然后将在数据表中写入0值

user := User{Name: "poole", Age: new(int64)}
db.Create(&user)

查询

检索单个对象

GORM 提供了First、Take、Last方法，以便从数据库中检索单个对象。 当查询数据库时它添加了LIMIT 1条件，且没有找到记录时，它会返回 错误ErrRecordNotFound

//获取第一条数据，主键升序
db.First(&user)
// SELECT * FROM users ORDER BY id LIMIT 1;

// 获取一条记录，没有指定排序字段
db.Take(&user)
// SELECT * FROM users LIMIT 1;

// 获取最后一条记录（主键降序）
db.Last(&user)
// SELECT * FROM users ORDER BY id DESC LIMIT 1;

result := db.First(&user)
result.RowsAffected // 返回找到的记录数
result.Error        // returns error or nil
根据主键检索
db.First(&user, 3)
// SELECT * FROM users WHERE id = 3;

db.First(&user, "10")
// SELECT * FROM users WHERE id = 10;

db.Find(&users, []int{1,2,3})
// SELECT * FROM users WHERE id IN (1,2,3);

对于传入的主键ID数据，将它放入User中，直接传递给First

user := User{ID: 2}
db.First(&user)

查询多个对象

查询全部对象：

db.Find(&users)
// SELECT * FROM users;

条件查询

string条件

获取第一个匹配的记录

db.Where("name=?", "green").First(&user)           
//SELECT * FROM users WHERE name = 'green' ORDER BY id LIMIT 1;

获取所有匹配的记录，所有不等于poole的数据

db.Where("name <> ?", "poole").Find(&users)
//SELECT * FROM users WHERE name <> 'poole';

IN

db.Where("name IN ?", []string{"green", "poole"}).Find(&users)
// SELECT * FROM users WHERE name IN ('green','poole');

LIKE

db.Where("name LIKE ?", "%jin%").Find(&users)
// SELECT * FROM users WHERE name LIKE '%jin%';

AND

db.Where("name = ? AND age >= ?", "jinzhu", "22").Find(&users)
// SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;
struct & map 条件

struct

db.Where(&User{Name: "poole", Age: 23}).First(&user)
//SELECT * FROM users WHERE name = "poole" AND age = 23 ORDER BY id LIMIT 1;

map

db.Where(map[string]interface{}{"name": "poole", "age": 23}).Find(&users)
// SELECT * FROM users WHERE name = "poole" AND age = 23;

slice：切片中数据的主键查询

db.Where([]int64{2, 3, 5}).Find(&users)
// SELECT * FROM users WHERE id IN (2, 3, 5);

需要注意的是，查询条件有零元素的时候，需要使用map的形式，而不是struct的形式

//struct
db.Where(&User{Name: "poole", Age: 0}).Find(&users)
// SELECT * FROM users WHERE name = "poole";

//map
db.Where(map[string]interface{}{"Name": "poole", "Age": 0}).Find(&users)
// SELECT * FROM users WHERE name = "poole" AND age = 0;
内联条件

查询条件可以内联到First和Find等方法中，其方式与 Where 类似。

//二者是等价的
db.Where("id=?", 2).First(&user)
db.First(&user, "id=?", 2)
Not条件
db.Not("name=?", "looney").Find(&users)
//select * from users where not name ="looney" order by id;
Or条件
db.Where("name=?", "looney").Or("name=?", "poole").Find(&users)
//select * from users where name ="looney" or name ="poole";

选择特定字段

db.Select("name", "age").Find(&users)
//select name,age from users;

排序

db.Order("age desc, name").Find(&users)
//select * from users order by age desc,name;
db.Order("age desc").Order("name").Find(&users)
//select * from users order by age desc,name;

Limit & Offset

db.Limit(3).Find(&users)
//select * from users limit 3;

db.Limit(2).Offset(1).Find(&users)
//select * from users limit 2 offset 1;

高级查询

智能选取字段

GORM 允许通过 Select 方法选择特定的字段，如果您在应用程序中经常使用此功能，你也可以定义一个较小的结构体，以实现调用 API 时自动选择特定的字段，例如：

type User struct {
	ID   int64
	Name string
	Age  int64
}

type ApiUser struct {
	ID   int64
	Name string
}

users := []ApiUser{}
db.Model(&User{}).Limit(3).Find(&users)
fmt.Printf("%v\n", users)
//select id,name from users limit 3;
//[{1 poole} {2 looney} {3 green}]

子查询

子查询可以嵌套在查询中，GORM 允许在使用 *gorm.DB 对象作为参数时生成子查询

db.Where("amount > (?)", db.Table("orders").Select("AVG(amount)")).Find(&orders)
//SELECT * FROM "orders" WHERE amount > (SELECT AVG(amount) FROM "orders");

更新

保存所有字段

Save 会保存所有的字段，即使字段是零值

user := User{}
db.First(&user)
user.Name = "poole"
db.Save(&user)

更新单列

使用Update更新单列时，需要有一些条件，否则将会引起错误 ErrMissingWhereClause

//条件更新
db.Model(&User{}).Where("id=?", 2).Update("age", 26)
//update users set age =26 where id =2;

//根据user的值进行更新
user := User{ID: 2}
db.Model(&user).Update("name", "Kevin Rooney")
//update users set name="Kevin Rooney" where id =2;

//根据条件和user的值进行更新
db.Model(&user).Where("age=?", 26).Update("name", "looney")
//update users set name="looney" where id =2 and age =26;

更新多列

Updates方法支持struct和map[string]interface{}参数

//根据 struct 更新属性，只会更新非零值的字段
user := User{ID: 3}
db.Model(&user).Updates(User{Name: "Kevin", Age: 27})
//update users set name ="Kevin",age =27 where id =3;

//根据map更新属性
db.Model(&user).Updates(map[string]interface{}{"name": "green", "age": 32})
//update users set name ="green",age =32 where id =3;

更新选定字段

如果您想要在更新时选定、忽略某些字段，您可以使用 Select、Omit

//选定某些字段
db.Model(&user).Select("age").Updates(User{Name: "green", Age: 27})
//update users set age =27 where id = 3;

//忽略某些字段
db.Model(&user).Omit("name").Updates(User{Name: "green", Age: 27})
//update users set age =27 where id = 3;

批量更新

db.Model(User{}).Where("age=?", 23).Updates(User{Name: "super start"})
//update users set name = "super start" where age = 23;
阻止全局更新

如果在没有任何条件的情况下执行批量更新，默认情况下，GORM 不会执行该操作，并返回ErrMissingWhereClause 错误

db.Model(&User{}).Update("name", "poole").Error // gorm.ErrMissingWhereClause

db.Model(&User{}).Where("1 = 1").Update("name", "poole")
// UPDATE users SET `name` = "poole" WHERE 1=1

db.Exec("UPDATE users SET name = ?", "poole")
// UPDATE users SET name = "poole"

db.Session(&gorm.Session{AllowGlobalUpdate: true}).Model(&User{}).Update("name", "poole")
// UPDATE users SET `name` = "poole"
更新记录数量
tx := db.Model(User{}).Where("age=?", 23).Updates(User{Name: "mvp"})
fmt.Printf("%v\n", tx.RowsAffected)

使用sql表达式更新

db.Model(&product).Update("price", gorm.Expr("price * ? + ?", 2, 100))
// UPDATE "products" SET "price" = price * 2 + 100 WHERE "id" = 3;

删除

删除一条记录

删除一条记录时，删除对象需要指定主键，否则会触发批量delelte

user := User{ID: 6}
db.Delete(&user)
//delete from users where id = 6;

//添加额外条件的删除
db.Where("name=?","green").Delete(&user)
//delete from users where id = 6 and name = "green"

根据主键删除

//主键可以使用数字或者字符串
db.Delete(&User{}, 7)
//delete from users where id =7;
db.Delete(&User{}, "7")
//delete from users where id =7;

db.Delete(&users, []int{1,2,3})
//delete from users where id in (1,2,3);

批量删除

如果指定的值不是主键，那么gorm会执行批量删除，它将删除所有匹配的记录

db.Where("name like ?", "%zhang%").Delete(&User{})
//delete from users where name like "%zhang%";

db.Delete(&User{}, "email like ?", "%zhang%")
//deleye from users where name like "%zhang%"

阻止全局删除

如果在没有任何条件的情况下执行批量删除，GORM 不会执行该操作，并返回 ErrMissingWhereClause 错误

db.Delete(&User{}).Error // gorm.ErrMissingWhereClause

db.Where("1 = 1").Delete(&User{})
// delete from `users` where 1=1;

db.Exec("DELETE FROM users")
// delete from  users;

db.Session(&gorm.Session{AllowGlobalUpdate: true}).Delete(&User{})
// delete from  users;

软删除

如果您的模型包含了一个 gorm.deletedat 字段（gorm.Model 已经包含了该字段)，它将自动获得软删除的能力！

user := User{ID: 7}
db.Delete(&user)
// update users set deleted_at="1999-10-29 23:23" where id = 7;

//查询时会忽略被软删除的记录
db.Where("age=20").Find(&user)
//select * from users where age = 20 and delete_at is null;

查询被软删除的记录

可以使用Unscoped找到被软删除的记录

db.Unscoped().Where("age = 20").Find(&users)
// select * from users where age = 20;

永久删除

使用Unscoped永久删除匹配的记录

db.Unscoped().Delete(&user)
// delete from users where id=10;
妮听得到
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Gin中使用GROM操作数据库-mysql数据（一）
09-27
关于使用grom来连接mysql数据的使用以及基础操作并且还扩展了使用主键用法。
grom系统文件
11-19
应用于系统其文件，文件丢失，可直接复制过去即可。主要针对Windows
Grom学习之路
yyq1102394156的博客
06-18 1259
Grom学习之路（一） 一、orm的背景 1、作用 （1）通过操作结构体对象，来达到操作数据库表的目的； （2）通过结构体对象，来生成数据库表； 2、优点： 二、grom的连接数据库，建表 1、因为grom只能对表进行操作，所以需要搭配sql语句来 ...
grom的理解与掌握
hightower的博客
05-07 818
前言 什么是gorm gorm是一种数据库操作辅助工具，在我们go的结构体和数据库之间产生映射，让我们对数据库的关系，标的内容，直观的体现在结构体上，使用结构体即可完成增删改查操作 使用gorm进行数据库操作 gorm如何链接数据库 导入gorm-------导入mysql驱动器----------使用open链接得到数据库操作对象(以mysql为例) do,err:=gorm.Open(“mysql”,“user:password@/dbname?charset=utf8&parseTime=Tr
Grom之数据查询
weixin_52690231的博客
05-03 3990
Grom之数据查询
golang gorm 查询和多条件拼接和多库查询实践
qq_32421489的博客
06-28 1455
golang gorm 查询和多条件拼接和多库查询实践
【Gorm】如何通过Gorm实现对数据库操作
Czh的博客
05-06 1580
我们完成了Gorm部分的学习，能够大致明白，如何通过Gorm来实现对数据库的操作，简化我们开发，提高开发效率。当然需要我们进一步在实际开发过程中去实践，才能更好的将这些知识转变为自己的东西！
Grom-开源
04-25
可移植的C ++库，用于开发可靠且可扩展的软件系统。
grom-site
03-22
现场
java-jdbc-grom
02-18
java-jdbc-grom
使用GORM操作数据库
有朋自远方来，不亦乐乎。
05-28 2594
1、下载安装pgsql 安装教程：Windows 上安装 PostgreSQL | 菜鸟教程 (runoob.com) 2、下载安装redis Redis 安装 | 菜鸟教程 (runoob.com)
Go 使用 Gorm 操作 MySQL 数据库
张云飞Vir的专栏
03-29 5896
0. 背景 在实际开发中，要用到数据库存储数据。MySQL是一个关系型数据库管理系统 使用非常广泛。在Go语言开发中，会选择一个操作数据的类库来帮助我们完成工作。 1. 简单介绍 1.1 MySQL 数据库介绍 MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，...
Go 语言编程 — gorm 数据库版本迁移
烟云的计算
10-08 8288
目录 文章目录目录AutoMigrate示例Migrator 接口（DDL 操作方法）表操作列操作约束操作索引操作数据库版本控制参考文档 AutoMigrate GORM 的 AutoMigrate() 方法用于自动迁移 ORM 的 Schemas。所谓 “迁移” 就是刷新数据库中的表格定义，使其保持最新（只增不减）。 AutoMigrate 会创建（新的）表、缺少的外键、约束、列和索引，并且会更改现有列的类型（如果其大小、精度、是否为空可更改的话）。但不会删除未使用的列，以保护现存的数据。 // 初始化一
gorm操作数据库
最新发布
qq_65150735的博客
09-13 148
ORM（对象关系映射）是一种编程技术，用于在关系型数据库和面向对象编程语言之间建立映射关系。ORM允许开发人员使用面向对象的方式操作数据库，而不需要直接编写SQL语句。它将数据库表格和记录映射为对象和类，使得开发人员可以使用面向对象的思维和技术来处理数据。ORM的主要目标是简化数据库操作和提高开发效率。它提供了一组API或工具，用于执行常见数据库操作，例如查询、插入、更新和删除数据。
golang学习笔记（6）-gorm实现查询功能
logiee的博客
08-12 6347
gorm实现记录查询功能的实验记录与学习笔记
1 GORM入门指南(golang)
行走的皮卡丘
08-29 1781
1 Grom入门指南 (golang)
Gorm之gorm特性、下载安装gorm依赖
weixin_52690231的博客
05-02 1254
Gorm之gorm特性、下载安装gorm依赖
golang gorm show tables
Enjun97的博客
09-20 1229
golang使用gorm组件进行原生sql查询show tables
Gorm操作数据库
weixin_51656756的博客
04-23 458
Name string `gorm:"default:'dazai'"` //设置name默认值，如果创建对象时没有传name，那么就会给赋默认值 Age int64 }
grom 连接数据库
05-26
在 Python 中使用 grom 连接数据库需要进行以下步骤： 1. 安装 grom 库 可以使用 pip 命令进行安装： ``` pip install grom ``` 2. 连接数据库 使用 grom.connect() 方法连接数据库，该方法接受一个字典参数，其中包含数据库连接信息。 例如连接 MySQL 数据库： ```python import grom db_config = { 'host': 'localhost', 'port': 3306, 'user': 'root', 'password': 'password', 'database': 'test_db' } conn = grom.connect('mysql', **db_config) ``` 3. 执行 SQL 查询 使用 conn.execute() 方法执行 SQL 查询并返回结果。 例如查询表中所有数据： ```python result = conn.execute('SELECT * FROM test_table') for row in result: print(row) ``` 这就是使用 grom 连接数据库的基本步骤，你可以根据自己的需要进行进一步的操作和优化。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值