GORM快速入门

最新推荐文章于 2024-04-30 21:17:49 发布
最新推荐文章于 2024-04-30 21:17:49 发布
阅读量658 收藏 5
点赞数 2
分类专栏： go 文章标签： golang 数据库 mysql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/EGXXM/article/details/124730258
版权

crud 指的creat retrieve update delete增加，查询，更新，删除四种操作

ORM,对象关系映射，是一种框架格式，显示了映射关系

迁移

创建表，查看表，重命名表，删除表

type User struct {
	ID   int
	Name string
}

func main() {
	db, err := gorm.Open(mysql.New(mysql.Config{
		DSN: "root:123456@tcp(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local",
	}), &gorm.Config{
		SkipDefaultTransaction: false, //是否跳过事务事件，事务事件使得数据更安全
		NamingStrategy: schema.NamingStrategy{
			TablePrefix:   "t_",  //表 添加前缀
			SingularTable: false, //表名设置为单数
		},
		DisableForeignKeyConstraintWhenMigrating: true, //数据库采用逻辑外键，访问速度更快
	})
	if err != nil {
		fmt.Println(err)
	}
	//_ = db.AutoMigrate(&User{})         //自动迁移
	M := db.Migrator() //手动迁移
	//M.CreateTable(&User{})             //创建表
	//fmt.Println(M.HasTable(&User{}))     //查看表是否存在，("t_user")用表名的形式也可以 但是最好用结构体的形式，方便清楚
	//fmt.Println(M.DropTable(&User{})) //删除表
	if M.HasTable(&User{}) {
		M.RenameTable(&User{}, "a_users") //如果存在表就改名
	} else {
		M.CreateTable(&User{})                     //不存在就创建表
	}
}
CRUD
创建
func CreatedTest() { //首字母大写，对其他目录可见
    //创建单条数据
	//GlobalDb.Create(&TestUser{Name: "景之", Age: 20}) //记得设置数据库编码格式为utf8
	//GlobalDb.Omit("Name").Create(&TestUser{Name: "景之", Age: 20})  跳过名字创建Age
	//GlobalDb.Select("Name").Create(&TestUser{Name: "景之", Age: 20}) 只创建Name
    
    //创建多条数据
	GlobalDb.Create(&[]TestUser{
		{Name: "景之", Age: 20},
		{Name: "郭龙", Age: 21},
		{Name: "弛子", Age: 20},
		{Name: "小艺", Age: 20},
	})
}
查询

以下查的好多都是单条数据，如果是要查询多条数据也很简单，只需要

var Users TestUser
//查询语句
GlobalDb.Find(&Users)
fmt.Println(Users)
//如此就可，就是换成了切片

查询单个对象

db.First(&user)

db.Take(&user)

db.Last(&user)

result := db.First(&user)
result.RowsAffected // 返回找到的记录数  比如说咱要找叫做小艺的同学，那么学校可能有好几个人叫小艺，几个就是记录数

查询map型切片和结构体

func TestFind() {
    //查询结构体，map型切片
	//var result = make(map[string]interface{})
	//GlobalDb.Model(&TestUser{}).First(&result)
    //fmt.Println(result)
	
	var User TestUser
    //根据主键排序查询
    //GlobalDb.Model(&TestUser{}).Take(&User)
    //GlobalDb.Model(&TestUser{}).First(&User)
	GlobalDb.Model(&TestUser{}).Last(&User)
	fmt.Println(User)
}

主键检索

//直接检索到第几条数据
db.First(&user, 10)
// SELECT * FROM users WHERE id = 10;

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);

查询总共有几条数据

var Users []TestUser //加上[] 就是切片，包含所有数据否则TestUser只是代表找到这个表（表就是结构体）
//查询所有对象
res := GlobalDb.Find(&Users) //返回error 和 RowsAffected
fmt.Println(res.RowsAffected) //输出有几条数据

//打印所有数据
var Users []TestUser 
//找到所有对象
GlobalDb.Find(&Users) 
fmt.Println(Users)

条件查询

//根据string字段查询
var User TestUser
//GlobalDb.Where("name = ?", "景之").First(&User)

GlobalDb.Where("name = ? AND age = 20", "景之").First(&User)

//GlobalDb.Where("name = ? AND age >= ?", "景之", "19").Find(&Users) //???

fmt.Println(User)
//官网还有好多，这只是最基本的用法
//<>排除这个的数据
//LIKE模糊，在条件位置加%%，例如%j%

内联

//string形式
GlobalDb.First(&User, "id = ?", 5)
//结构体形式
GlobalDb.First(&User, TestUser{Name: "jz"})
//map形式
GlobalDb.First(&User, map[string]interface{}{"Name": "jz"})

往下基本看文档自己都会

高级查询

智能字段，自定义api，

type UserInfo struct {
	//自定义智能字段
	Name string
	Age  uint8
}

func TestFind() {
	var u UserInfo
	GlobalDb.Model(&TestUser{}).Where("Name LIKE ?", "%小%").Find(&u)
	fmt.Println(u)
}
//结果是：{小艺 20}
更新

形式上和查询基本一样，最后的改为下边的三个关键词，对应即可

func TestUpdate() {
	//update 只更新选择的字段
	//updates 跟新所有字段，形式1 map 形式2 结构体，结构体零值不参与更新
	//save    everything更新
	GlobalDb.Model(&TestUser{}).Where("Name = ?", "jz").Update("name", "jz大帅哥")
}
删除
func TestDelete() {
	var user []TestUser
	//Unscoped真的删除这一行，没有Unscoped是软删除
	//gorm.Model含有gorm.deletedat，拥有软删除的能力
	//拥有软删除能力的模型调用 Delete 时，记录不会被数据库。但 GORM 会将 DeletedAt 置为当前时间， 并且你不能再通过普通的查询方法找到该记录。
	GlobalDb.Unscoped().Where("namE", "jz大帅哥").Delete(&user) //name这种条件都是大小写不太区分的
}
原生
GlobalDb.Row(原生语句)
关联
belongsTo

belongs to 会与另一个模型建立了一对一的连接

这种模型的每一个实例都“属于”另一个模型的一个实例

//GirlGod可以有很多个User
type User struct {
  gorm.Model
  Name      string
  GirlGodID int
  GirlGod GirlGod
}

type GirlGod struct {
  ID   int
  Name string
}

预加载

var girl GirlGod
GlobalDb.Preload("Dog").First(&girl, 2)
fmt.Println(girl)
//女神出门带着添狗，preload预加载，把天狗带上
Has One
// User 有一张 CreditCard，UserID 是外键
type User struct {
  gorm.Model
  GirlGod GirlGod // 追随者有了女神
}

type GirlGod struct {
  gorm.Model
  Number string
  UserID uint //女神带有追随着
}
Has Many

和has one 区别就是，把Dog变成了Dogs切片

type Dog struct {
	gorm.Model
	Name      string
	GirlGodID uint //狗链子

}

type GirlGod struct {
	gorm.Model
	Name string
	Dogs []Dog //拿到狗链子
}

func One2one() {
	d1 := Dog{
		Model: gorm.Model{
			ID: 1,
		},
		Name: "汪汪1号",
	}
	d2 := Dog{
		Model: gorm.Model{
			ID: 2,
		},
		Name: "汪汪2号",
	}
	g := GirlGod{
		Model: gorm.Model{
			ID: 1,
		},
		Name: "女神",
		Dogs: []Dog{d1, d2}, //汪汪1号和汪汪2号都在追女神 ID都是1
	}
	GlobalDb.Create(&g)

查询

//预加载全部
var girl GirlGod
GlobalDb.Preload("Dogs").First(&girl)
fmt.Println(girl)
//选择性预加载。内联式查询
GlobalDb.Preload("Dogs", "name = ?", "汪汪1号").First(&girl)
//当条件很多时候，可以用个函数
GlobalDb.Preload("Dogs", func(db *gorm.DB) *gorm.DB{
    return db.Where("name = ?", "汪汪1号")
}).First(&girl)
多态
  • 支持一对一和一对多
type Jiazi struct {
	ID          uint
	Name        string
	Xiaofengche Xiaofengche `gorm:"polymorphic:Owner;"`
}
type Yujie struct {
	ID          uint
	Name        string
	Xiaofengche Xiaofengche `gorm:"polymorphic:Owner;"`
}
type Xiaofengche struct {
	ID        uint
	Name      string
	OwnerType string
	OwnerID   uint
}

func Polymorphic() {
	GlobalDb.Create(&Jiazi{Name: "夹子", Xiaofengche: Xiaofengche{
		Name: "小风车",
	}})
	GlobalDb.Create(&Yujie{Name: "御姐", Xiaofengche: Xiaofengche{
		Name: "大风车",
	}})
}
关联外键

关联id

type Jiazi struct {
	ID          uint
	Name        string
	Xiaofengche []Xiaofengche `gorm:"foreignKey:JiaziName"` //还是关联的id,只不过起的名字叫jiazi_name
}
type Xiaofengche struct {
	ID        uint
	Name      string
	JiaziName string
}

func Polymorphic() {
	GlobalDb.AutoMigrate(&Jiazi{}, &Xiaofengche{})
	GlobalDb.Create(&Jiazi{Name: "大夹子", Xiaofengche: []Xiaofengche{
		{Name: "小风车1"},
		{Name: "小风车2"},
	}})
}

关联Name

  • 把关联语句换为下边这个
  • references引用指向自己，大夹子
`gorm:"foreignKey:JiaziName;references:Name"`
事务
单层普通事务
type TMG struct {
	ID   uint
	Name string
}

func TestTransaction() {
	flag := false
	GlobalDb.AutoMigrate(&TMG{})
	GlobalDb.Transaction(func(tx *gorm.DB) error {
		tx.Create(&TMG{Name: "汉子"})
		tx.Create(&TMG{Name: "高大威猛"})
		fmt.Println("上边执行过了")
		if flag {
			return nil
		} else {
			return errors.New("躲开汉子")
		}
	})
}
嵌套事务
func TestTransaction() {
	GlobalDb.AutoMigrate(&TMG{})
	GlobalDb.Transaction(func(tx *gorm.DB) error {
		tx.Create(&TMG{Name: "高大威猛"})
		tx.Transaction(func(tx *gorm.DB) error {
			tx.Create(&TMG{Name: "汉子"})
			return errors.New("躲开了汉子")
		})
		fmt.Println("执行高大威猛出现，汉子不出现")
		return nil
	})
}
手动事务
//手动事务
	tx := GlobalDb.Begin()
	tx.Create(&TMG{Name: "汉子"})
	tx.Create(&TMG{Name: "高大威武"})
	tx.Commit()
SavePoint、RollbackTo
tx := GlobalDb.Begin()
tx.Create(&TMG{Name: "汉子"})
tx.SavePoint("duo")
tx.Create(&TMG{Name: "高大威武"})
tx.RollbackTo("duo")
tx.Commit()

总结：写的有点乱了，我尽量给他整清楚了，因为我也是看b站up主+看文档学习有点乱，但是我真的尽量整清楚了。

不之道
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Go语言学习笔记—gorm(一)
qq_39280718的博客
08-12 1689
对象关系映射（Object-Relationl Mapping，简称ORM）模式是一种为了解决面向对象和关系数据库（如mysql数据库）存在的互相不匹配的现象的技术。
Go快速入门强化
06-16
《Go快速入门强化》 Go语言，又称为Golang，是由Google公司开发的一种静态类型、编译型的、并发型且具有垃圾回收功能的编程语言。Go语言的设计目标是提高开发者的生产力，同时保持系统级编程的性能。本节内容将深入...
【Gorm】Gorm基础入门
Czh的博客
04-27 1174
本文主要初步了解Gorm是什么，Gorm有什么用进行讲解，包括gorm在写法中如何与表进行相对应进行举例说明，最后抛出如何与当前主流的数据库进行连接。
【ORM框架】go语言ORM框架 - gorm快速入门
Jzin的博客
01-10 885
gorm快速入门
一篇文章讲完 Gorm 入门所有使用
最新发布
weixin_55818116的博客
04-30 1080
一篇文章教你如何使用Gorm框架，不信快来看看吧！
gorm使用指南（简单入门）
m0_66316879的博客
03-02 1623
gorm
GORM（上）
qq_53267860的博客
02-20 440
目录GORM安装连接MySQLGORM Model定义结构体标记（tags）支持的结构体标记（Struct tags）关联相关标记（tags）主键、表名、列名的约定主键（Primary Key）表名（Table Name）列名（Column Name）时间戳跟踪CreatedAtUpdatedAtDeletedAt GORM 安装 go get -u github.com/jinzhu/gorm 连接MySQL package main import ( "fmt" "github.com/
Gorm 入门介绍与基本使用
淘小欣的博客
01-10 1180
ORM（Object-Relational Mapping）是一种编程技术，它将对象和关系数据库之间的映射抽象出来，使得开发者可以通过面向对象的方式操作数据库，而不用直接处理SQL语句，相当于在业务逻辑层和数据库层之间一座桥梁。在Golang中，有一款优秀的ORM框架叫做Gorm，它提供了强大的功能，使得数据库操作变得更加简单和灵活。开发者需要定义数据模型，通常是一个结构体，表示数据库中的表结构。Gorm是一款用于Golang的ORM框架，它提供了丰富的功能，包括模型定义、数据验证、关联查询等。
GORM 快速入门最佳实践（含有样例数据库）
Lance_Yuan24的博客
05-18 5486
在听完JINZHU老师对GORM的讲解后，我对于GORM的理解更深一层，有回忆到学习GORM时网络上基本没有带样例数据库的教程，所以在今天带着样例数据库写一篇GORM的简单入门教程（基础使用） 我所展示的实现效果与代码可能会有一定出入，这是因为我展示中的数据库模型更加完善但不适合教程使用，但是不妨碍学习。
带你快速上手gorm一一基础知识汇总
m0_63512120的博客
02-20 1100
orm即Object-Relational Mapping，它的作用是在关系型数据库和对象之间作一个映射，这样，我们在具体的操作数据库的时候，就不需要再去和复杂的SQL语句打交道，只要像平时操作对象一样操作它就可以了。
Gin+Gorm开发Golang API快速开发脚手架-Golang开发
05-26
Gin+Gorm开发Golang API快速开发脚手架 Singo Singo: Simple Single Golang Web Service go-crud正式改名为Singo! 使用Singo开发Web服务: 用最简单的架构，实现够用的框架，服务海量用户 ... Singo文档 ...
gorm文档_英文.pdf
09-14
gorm文档的开始部分讲解了如何使用gorm库，包括安装、升级到V1.0、快速入门等内容。同时，也提到了gorm库的特点，如 Associations、Callbacks、Preloading、Transactions、Composite Primary Key、SQL Builder、Auto...
GORM mysql驱动程序-Golang开发
05-26
GORM mysql驱动程序GORM MySQL驱动程序快速入门import（“ gorm.io/driver/mysql”“ gorm.io/gorm”）// https://github.com/go-sql-driver/mysql dsn：=“ gorm： gorm @ tcp（localhost：9910）/ gorm？...
grails 入门大全
03-01
- GORM（Grails Object-Relational Mapping）是Grails的数据持久化层，提供了与数据库交互的能力，支持多种数据库。 3. **Grails 插件系统** - Grails 的强大之处在于其丰富的插件生态，通过安装插件可以快速添加...
golang 学习 gorm 快速入门
youandme520的专栏
02-19 545
一个神奇的，对开发人员友好的 Golang ORM 库 安装 go get -u github.com/jinzhu/gorm 快速开始 package main import ( "github.com/jinzhu/gorm" _ "github.com/jinzhu/gorm/dialects/sqlite" ) type Product struct { gorm.Model Code string Price uint } func main() { db
gorm快速上手
新法的博客
03-08 1921
ORM全称是:Object Relational Mapping(对象关系映射)，其主要作用是在编程中，把面向对象的概念跟数据库中表的概念对应起来。举例来说就是，我定义一个对象，那就对应着一张表，这个对象的实例，就对应着表中的一条记录。​ 对于数据来说，最重要最常用的是表:表中有列, orm就是将一张表映射成一个类，表中的列映射成类中的一个类。java 、python，但是针对go语言而言，struct，就是列如何映射，是因为列可以映射成struct中的类型，int->int,但是有另一个问题?
【转载】Groovy轻松入门——Grails实战之GORM篇
mht13895099346的专栏
02-29 118
Groovy轻松入门——Grails实战之GORM篇（更新于2007年4月8日） GORM就是以前我刚学Groovy没多久时想实现的功能，它使开发人员不需要关心数据库方面，也不需要任何配置，只需专心用OO思想设计自己的系统，还有一个好处就是开发时不用备份数据库，因为GORM会自动帮你建表以及约束（但数据库需要你自己建），让我们来看一下用Grails开发是多么简单高效吧！ 在Grails0.6+中，...
4 GROM 教程 (golang)
行走的皮卡丘
08-29 1173
4 GROM 教程 (golang)
GORM 笔记 One to One
Software is hard
01-08 194
例子中用Face 和 Nose作关系的例子 一对一有3种情况: 1.Nose作为Face的一个属性保存. 也就是说Nose 相当于 Face的一个内部类. 2.双向关联 3.级联关联 如果在Nose中设置的是 [code="java"] static belongsTo = Face static belongsTo = [face:Face] [/code] 的区...
gorm scopes
04-27
gorm scopes是Golang中使用的一种功能，用定义和应用查询作用域。它可以帮助我们在查询数据库时，根据不同的条件和需求，动态地构建查询语句。 使用gorm scopes，我们可以将一组查询条件封装成一个作用域(scope)，然后在需要的时候应用到查询中。这样可以使代码更加模块化和可复用，同时也能提高查询的灵活性和可读性。 在gorm中，我们可以通过定义结构体的方法来创建作用域。这些方法需要接收一个gorm.DB类型的参数，并返回一个gorm.DB类型的结果。在方法内部，我们可以使用gorm提供的各种查询方法来构建查询条件，例如Where、Order、Limit等。 下面是一个使用gorm scopes的示例： ```go type User struct { ID uint Name string Age int } func (db *gorm.DB) AgeGreaterThan(age int) *gorm.DB { return db.Where("age > ?", age) } func main() { db, err := gorm.Open("mysql", "user:password@tcp(localhost:3306)/database") if err != nil { panic(err) } defer db.Close() var users []User db.Scopes(db.AgeGreaterThan(18)).Find(&users) } ``` 在上面的示例中，我们定义了一个名为AgeGreaterThan的作用域，它接收一个年龄参数，并返回一个添加了查询条件的gorm.DB对象。然后，在main函数中，我们通过调用Scopes方法并传入AgeGreaterThan作用域，来应用该作用域到查询中。 这样，最终执行的查询语句将会是`SELECT * FROM users WHERE age > 18`，并将结果存储到users变量中。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

不之道

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值