两万字长文，手把手带你走进GORM框架！

一、下载PG数据库（Windows）

1、下载安装pgsql

2、下载安装redis（暂时用不上）

二、Go连接PG数据库

z、\*

a、建库：

b、入库

c、建表：

d、查询：

e、插入：

f、删除：

1、方法1：使用pq包连接

（1）在src目录下，获取包

（2）下载库管理依赖包go.mod：

（3）下载go.sum:

（4）导入依赖包github/lib/pq@latest：

（5）回到VScode使用连接代码：

（7）输出连接成功：

（8）总结1：

2、查询

（1）、查询全部信息：

（2）查询单个信息：

3、插入

4、修改

5、删除

三、进阶：使用GORM框架连接操作数据库

（0）创建数据库（MySQL语法）：

（1）建立连接：

（2）进行表操作

（3）增

（4）查

（5）改

（6）删

（7）总结2

四、官方示例

1、导入包:

2、创建表名和表结构

3、连接数据库

4、创建likes数据表

5、插入

6、删除：

7、查询

8、修改

9、事务：

10、完整代码：

一、下载PG数据库（Windows）

1、下载安装pgsql

安装教程：Windows 上安装 PostgreSQL | 菜鸟教程 (runoob)

2、下载安装redis（暂时用不上）

Redis 安装 | 菜鸟教程 (runoob)

二、Go连接PG数据库

先进行准备工作，在数据库管理系统中创建测试用的数据库和表

z、\*

1、列举出数据库中的表
zldd_user=> \d  

2、列举创建的数据库
zldd_user=> \l  

3、退出
postgres-# \q

a、建库：

CREATE DATABASE ProductsManage;

b、入库

\c productsmanage;

c、建表：

CREATE TABLE products (
    product_no integer,
    name text,
    price numeric
);

d、查询：

select * from products;

e、插入：

INSERT INTO products VALUES (1, 'Cheese', 9.99);

f、删除：

drop table products;

1、方法1：使用pq包连接

golang基础-Postgresql使用、Go中使用PostgreSQL（github/lib/pq学习）_进击的小猿的博客-CSDN博客_golang pgsql

参考文档：

cpq 包装 - github/lib/pq - pkg.go.dev

（1）在src目录下，获取包

输入指令：

go get github/lib/pq

出现问题：

解决问题：

解决go: go.mod file not found in current directory or any parent directory； see ‘go help modules‘_林猛男的博客-CSDN博客

（2）下载库管理依赖包go.mod：

（在代码文件夹环境下的命令行中执行以下操作）

（3）下载go.sum:

go mod tidy

（4）导入依赖包github/lib/pq@latest：

go mod download github/lib/pq@latest

（5）回到VScode使用连接代码：

代码1：

package main

import (
	"database/sql"

	_ "github/lib/pq"
)

var db *sql.DB

func sqlOpen() {
	var err error
	db, err = sql.Open("postgres", "port=5432 user=postgres password=123456 dbname=productsmanagesslmode=disable")
	println("连接成功！")
	//sslmode就是安全验证模式;

	//或者这种方式打开
	//db, err := sql.Open("postgres", "postgres://pqgotest:postgres@localhost/pqgotest?sslmode=verify-full")
	if err != nil {
		panic(err)
	}
}

func main() {
	sqlOpen()
}

代码2：

package main

import (
	"database/sql"
	"fmt"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func main() {

	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)
	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}
	defer db.Close()

	err = db.Ping()
	if err != nil {
		panic(err)
	}

	fmt.Println("Successfully connected!")
}

（上述代码写法格式上略有不同，效果相同，相对而言，我觉得第二个更优美一些）

（7）输出连接成功：

您还可以使用URL连接到数据库。例如:

connStr := "postgres://pqgotest:password@localhost/pqgotest?sslmode=verify-full"
db, err := sql.Open("postgres", connStr)

（8）总结1：

与以前学习过的C语言、C++项目代码执导入头文件有所不同，每次go代码想要导入外部依赖时项目文件夹中必须含有go.mod文件和go.sum文件

下载方法就是在项目文件夹中调用命令行：

//初始化模块：
Go mod init <项目模块名称>

//依赖关系处理，根据go.mod文件
Go mod tidy

//下载依赖
Go mod download [path@version]

其他命令有：

//将依赖包复制到项目的vendor目录
Go mod vendor

//显示依赖关系
Go list -m all

//显示详细依赖关系
Go list -m -json all

2、查询

还记得一开始我们建的表吗，里面有一个学生信息：
我们现在通过go语言把它查出来：

（1）、查询全部信息：

package main

import (
	"database/sql"
	"fmt"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func connectDB() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}

	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}

func query(db *sql.DB) {
	var id, name, price string

	rows, err := db.Query(" select * from products where name=$1", "Cheese")

	if err != nil {
		fmt.Println(err)
	}
	defer rows.Close()

	for rows.Next() {
		err := rows.Scan(&id, &name, &price)

		if err != nil {
			fmt.Println(err)
		}
	}

	err = rows.Err()
	if err != nil {
		fmt.Println(err)
	}

	fmt.Println(id, name, price)
}

func main() {
	db := connectDB()
	query(db)

}

输出：

（2）查询单个信息：

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func connectDB() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}

	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}

func query_one(db *sql.DB) {
	var price string
	err := db.QueryRow(" select price from products where name=$1", "Cheese").Scan(&price)
	if err != nil {
		if err == sql.ErrNoRows {

		} else {
			log.Fatal(err)
		}
	}
	fmt.Println(price)
}
func main() {
	db := connectDB()
	query_one(db)

}

输出：

3、插入

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func connectDB() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}

	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}

func insertUser(db *sql.DB) {
	stmt, err := db.Prepare("insert into products(product_no,name,price) values($1,$2,$3)")
	if err != nil {
		log.Fatal(err)
	}
	_, err = stmt.Exec(6, "dump", "10.88")
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("insert into user_tbl success")
	}
}

func main() {
	db := connectDB()
	insertUser(db)
}

输出：

查询全部信息可以看到已经插入成功了。

4、修改

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func connectDB() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}

	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}

func UpdateUser(db *sql.DB) {
	stmt, err := db.Prepare("UPDATE  products  set price=$1 WHERE  product_no=$2")
	if err != nil {
		log.Fatal(err)
	}
	_, err = stmt.Exec("11.88", 6)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("udpate user_tbl success")
	}

}

func main() {
	db := connectDB()
	UpdateUser(db)
}

输出：

5、删除

package main

import (
	"database/sql"
	"fmt"
	"log"

	_ "github/lib/pq"
)

const (
	host     = "localhost"
	port     = 5432
	user     = "postgres"
	password = "123456"
	dbname   = "productsmanage"
)

func connectDB() *sql.DB {
	psqlInfo := fmt.Sprintf("host=%s port=%d user=%s "+
		"password=%s dbname=%s sslmode=disable",
		host, port, user, password, dbname)

	db, err := sql.Open("postgres", psqlInfo)
	if err != nil {
		panic(err)
	}

	err = db.Ping()
	if err != nil {
		panic(err)
	}
	return db
}

func DeleteUser(db *sql.DB) {
	stmt, err := db.Prepare("DELETE  FROM products WHERE  product_no=$1")
	if err != nil {
		log.Fatal(err)
	}

	_, err = stmt.Exec(6)
	if err != nil {
		log.Fatal(err)
	} else {
		fmt.Println("delete form user_tbl success")
	}
}

func main() {
	db := connectDB()
	DeleteUser(db)
}

输出：

三、进阶：使用GORM框架连接操作数据库

参考文章：

Gorm用法介绍 · Go语言中文文档 (topgoer)

(2条消息) golang学习之gorm(一):Gorm介绍_浅弋、璃鱼的博客-CSDN博客_gorm

因为没找到postgres的教程，此处我以mysql为例，因为思想大同小异，后面我在更改为pg，此处先把框架学会。

（0）创建数据库（MySQL语法）：

create table database；

（1）建立连接：

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

// UserInfo 用户信息
type UserInfo struct {
	ID     uint
	Name   string
	Gender string
	Hobby  string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	fmt.Println("连接成功！")
	defer db.Close()
}

如果缺少模块，就在终端里面缺什么补什么。

输出，连接成功。

（2）进行表操作

自动迁移（创建表）

为什么叫数据迁移，我暂且肤浅的认为就是将想要存储的信息从代码里迁移到数据库中。

db.AutoMigrate(&User{})
// 创建表时添加表后缀
db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	fmt.Println("连接成功！")
	//defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})

}

当我们执行上述代码时，打开数据库会查看到相关表信息，

查看表结构会发现与我们的数据定义的结构体一致。

创建表就成功了。

（3）增

提供两种写法，一种适合自动生成主键id序号，

第二种支持普通创建要自己写主键id。

    //第一种写法：
    if err := db.Create(&User{
		Name: "李四",
		Age:  18,
		Addr: "金石滩",
		Pic:  "image.jpg",
	}).Error; err != nil {
		fmt.Println("插入失败", err)
		return
	} else {
		fmt.Println("插入成功！")
	}

	//第二种插入方法
	u1 := User{1, "麻瓜", 18, "金石滩", "image.jpg"}
	db.Create(&u1)
	//判断成败
	if err := db.Create(&u1).Error; err != nil {
		fmt.Println("插入失败", err)
		return
	}

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

type Product struct {
	Id    int
	Name  string
	Price string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB").AutoMigrate(&User{})

	//第一种写法：
	db.Create(&User{
		Id:   1,
		Name: "张三",
		Age:  18,
		Addr: "金石滩",
		Pic:  "image.jpg",
	})

	//第二种插入方法
	u1 := User{2, "麻瓜", 18, "金石滩", "image.jpg"}
	db.Create(&u1)
	//判断成败
	if err := db.Create(&u1).Error; err != nil {
		fmt.Println("插入失败", err)
		return
	}
}

这段代码执行后会输出：

因为我们的名字都是中文，这里数据表没有设置默认字符为utf8，所以会报错。

所以在建表时要设置默认字符集为utf8：

db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

因为原表已经建好就不能修改了所以我们删表重建

DROP TABLE users;

再次插入中文名信息：

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

type Product struct {
	Id    int
	Name  string
	Price string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	//第一种写法：
	if err := db.Create(&User{
		Name: "李四",
		Age:  18,
		Addr: "金石滩",
		Pic:  "image.jpg",
	}).Error; err != nil {
		fmt.Println("插入失败", err)
		return
	} else {
		fmt.Println("插入成功！")
	}

	//第二种插入方法
	/*
		u1 := User{2, "麻瓜", 18, "金石滩", "image.jpg"}
		db.Create(&u1)
		//判断成败
		if err := db.Create(&u1).Error; err != nil {
			fmt.Println("插入失败", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/
}

这样就能看到数据表中已经有姓名信息了：

（4）查

	//查询表中第一个信息
	var u User
	db.First(&u)
	fmt.Println(u) // {1 张三 18 北京市 /static/img.png}

	var u_ = new(User)
	db.First(u_)
	fmt.Printf("%#v\n", u)

	//按值查询
	var uu User
	db.Find(&uu, "Id=?", 3)
	fmt.Printf("%#v\n", uu)

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

type Product struct {
	Id    int
	Name  string
	Price string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	//查询表中第一个信息
	var u User
	db.First(&u)
	fmt.Println(u) // {1 张三 18 北京市 /static/img.png}

	var u_ = new(User)
	db.First(u_)
	fmt.Printf("%#v\n", u)

	//按值查询
	var uu User
	db.Find(&uu, "Id=?", 3)
	fmt.Printf("%#v\n", uu)
}

输出：

（5）改

	//先找到目标地址（find）
	var user User
	db.First(&user) //将第一行的数据信息传给user
	user.Name = "狗蛋"
	db.Save(&user)
	fmt.Println(user)

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

type Product struct {
	Id    int
	Name  string
	Price string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	//先找到目标地址（find）
	var user User
	db.First(&user) //将第一行的数据信息传给user
	user.Name = "狗蛋"
	db.Save(&user)
	fmt.Println(user)
}

输出

更改指定值：

	//更改指定·值
	var uu User
	db.Find(&uu, "Id=?", 3)
	db.Model(&uu).Update("Name", "哈利")

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

type Product struct {
	Id    int
	Name  string
	Price string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	//更改指定·值
	var uu User
	db.Find(&uu, "Id=?", 3)
	db.Model(&uu).Update("Name", "哈利")
}

输出：

（6）删

//删除操作
	var u User
	db.Find(&u, "Id", "1") //删除id为1的信息
	db.Delete(&u)

删除过猛，直接全删没了，我淦。

在新添几个数据进行操作吧：

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	u1 := User{1, "哈利", 16, "霍格沃茨", "1.jpg"}
	u2 := User{2, "波特", 18, "格兰芬多", "2.jpg"}
	// 创建记录
	db.Create(&u1)
	db.Create(&u2)
	// 查询
	var u = new(User)
	db.First(u)
	fmt.Printf("%#v\n", u)
}

删除哈利：

	db.Delete(u);

(查询时u已经指向哈利了)

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	u1 := User{1, "哈利", 16, "霍格沃茨", "1.jpg"}
	u2 := User{2, "波特", 18, "格兰芬多", "2.jpg"}
	// 创建记录
	db.Create(&u1)
	db.Create(&u2)
	// 查询
	var u = new(User)
	db.First(u)
	fmt.Printf("%#v\n", u)
	//删除
	db.Delete(u)
}

输出：

删除波特：

// 查找
	var u = new(User)
	db.Find(u, "Id=?", 2)
	fmt.Printf("%#v\n", u)
	//删除
	db.Delete(u)

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
)

type User struct {
	Id   int
	Name string
	Age  int
	Addr string
	Pic  string
}

func main() {
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	// 自动迁移
	db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").AutoMigrate(&User{})

	u1 := User{1, "哈利", 16, "霍格沃茨", "1.jpg"}
	u2 := User{2, "波特", 18, "格兰芬多", "2.jpg"}
	// 创建记录
	db.Create(&u1)
	db.Create(&u2)
	// 查询
	var u = new(User)
	db.Find(u, "Id=?", 2)
	fmt.Printf("%#v\n", u)
	//删除
	db.Delete(u)
}

输出：

（7）总结2

给我的感觉就是在go语言定义一个指针变量。指针指向数据表中的信息。将数据表的信息复制给指针变量。对指针变量进行的操作与更改就会是指针所指的数据表地址中信息发生改变。

四、官方示例

前面基操还不爽，在找个官方示例跑一跑。

1、导入包:


import (
	"fmt"
	"strings"
	"time"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	"github/spaolacci/murmur3"
	_ "github/spaolacci/murmur3"
)

2、创建表名和表结构

type Like struct {
	ID    int    `gorm:"primary_key"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:hash_idx;"`
	//CreatedAt time.Time
}

3、连接数据库

	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()

4、创建likes数据表

//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}

5、插入

	//插入数据
	like := &Like{
		Ip:    "123",
		Ua:    "111",
		Title: "gorm",
		Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
		//CreatedAt: time.Now(),
	}
	if err := db.Create(like).Error; err != nil {
		fmt.Println("插入失败！", err)
		return
	} else {
		fmt.Println("插入成功！")
	}

6、删除：

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	_ "github/spaolacci/murmur3"
)

type Like struct {
	ID    int    `gorm:"type:int(255);not null"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:not null;"`
	//CreatedAt time.Time
}

func main() {
	//连接数据库
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}
	/*
		//插入数据
		like := &Like{
			Ip:    "123",
			Ua:    "111",
			Title: "gorm",
			Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
			//CreatedAt: time.Now(),
		}
		if err := db.Create(like).Error; err != nil {
			fmt.Println("插入失败！", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/

	//删除（通过数据表中的Ip值进行删除）
	if err := db.Where(&Like{Hash: 5865620638683223010}).Delete(Like{}).Error; err != nil {
		fmt.Println("删除失败！", err)
		return
	} else {
		fmt.Println("删除成功！")
	}
}

结果：

7、查询

//查询
	var count int
	if err := db.Model(&Like{}).Where(&Like{Ip: "123", Ua: "111", Title: "gorm"}).Count(&count).Error; err != nil {
		fmt.Println("查询失败！", err)
		return
	} else {
		fmt.Println(count)
	}

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	_ "github/spaolacci/murmur3"
)

type Like struct {
	ID    int    `gorm:"type:int(255);not null"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:not null;"`
	//CreatedAt time.Time
}

func main() {
	//连接数据库
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}
	/*
		//插入数据
		like := &Like{
			Ip:    "123",
			Ua:    "111",
			Title: "gorm",
			Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
			//CreatedAt: time.Now(),
		}
		if err := db.Create(like).Error; err != nil {
			fmt.Println("插入失败！", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/
	/*
		//删除（通过数据表中的Ip值进行删除）
		if err := db.Where(&Like{Hash: 5865620638683223010}).Delete(Like{}).Error; err != nil {
			fmt.Println("删除失败！", err)
			return
		} else {
			fmt.Println("删除成功！")
		}*/
	//查询
	var count int
	if err := db.Model(&Like{}).Where(&Like{Ip: "123", Ua: "111", Title: "gorm"}).Count(&count).Error; err != nil {
		fmt.Println("查询失败！", err)
		return
	} else {
		fmt.Println(count)
	}

}

输出：

8、修改

//修改
	var like Like
	db.Model(&like).Update("ip", "hello")                    //将ip改为hello
	db.Model(&like).Updates(Like{Ip: "world", Ua: "123"})    //将ip为world，ua改为123
	db.Model(&like).Updates(Like{Ip: "", Ua: "", Title: ""}) // nothing update

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	_ "github/spaolacci/murmur3"
)

type Like struct {
	ID    int    `gorm:"type:int(255);not null"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:not null;"`
	//CreatedAt time.Time
}

func main() {
	//连接数据库
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}
	/*
		//插入数据
		like := &Like{
			Ip:    "123",
			Ua:    "111",
			Title: "gorm",
			Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
			//CreatedAt: time.Now(),
		}
		if err := db.Create(like).Error; err != nil {
			fmt.Println("插入失败！", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/
	/*
		//删除（通过数据表中的Ip值进行删除）
		if err := db.Where(&Like{Hash: 5865620638683223010}).Delete(Like{}).Error; err != nil {
			fmt.Println("删除失败！", err)
			return
		} else {
			fmt.Println("删除成功！")
		}*/
	//查询
	/*
		var count int
		if err := db.Model(&Like{}).Where(&Like{Ip: "123", Ua: "111", Title: "gorm"}).Count(&count).Error; err != nil {
			fmt.Println("查询失败！", err)
			return
		} else {
			fmt.Println(count)
		}*/
	//修改
	var like Like
	db.Model(&like).Update("ip", "hello")                    //将ip改为hello
	db.Model(&like).Updates(Like{Ip: "world", Ua: "123"})    //将ip为world，ua改为123
	db.Model(&like).Updates(Like{Ip: "", Ua: "", Title: ""}) // nothing update
	
}

输出：

修该指定值

db.Model(&like).Where(&Like{Ip: "world"}).Updates(Like{Ip: "nihao", Ua: "222"})

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	_ "github/spaolacci/murmur3"
)

type Like struct {
	ID    int    `gorm:"type:int(255);not null"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:not null;"`
	//CreatedAt time.Time
}

func main() {
	//连接数据库
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}
	/*
		//插入数据
		like := &Like{
			Ip:    "123",
			Ua:    "111",
			Title: "gorm",
			Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
			//CreatedAt: time.Now(),
		}
		if err := db.Create(like).Error; err != nil {
			fmt.Println("插入失败！", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/
	/*
		//删除（通过数据表中的Ip值进行删除）
		if err := db.Where(&Like{Hash: 5865620638683223010}).Delete(Like{}).Error; err != nil {
			fmt.Println("删除失败！", err)
			return
		} else {
			fmt.Println("删除成功！")
		}*/
	//查询
	/*
		var count int
		if err := db.Model(&Like{}).Where(&Like{Ip: "123", Ua: "111", Title: "gorm"}).Count(&count).Error; err != nil {
			fmt.Println("查询失败！", err)
			return
		} else {
			fmt.Println(count)
		}*/
	//修改
	var like Like
	db.Model(&like).Where(&Like{Ip: "hello"}).Updates(Like{Ip: "nihao", Ua: "222"}) //将ip为world，ua改为123
}

输出：

9、事务：

func CreateAnimals(db *gorm.DB) error {
	//事务一旦开始，你就应该使用 tx 处理数据
	tx := db.Begin()
	defer func() {
	  if r := recover(); r != nil {
		tx.Rollback()
	  }
	}()
  
	if err := tx.Error; err != nil {
	  return err
	}
  
	if err := tx.Create(&Like{Ip: "Giraffe"}).Error; err != nil {
	   tx.Rollback()
	   return err
	}
  
	if err := tx.Create(&Like{Ip: "Lion"}).Error; err != nil {
	   tx.Rollback()
	   return err
	}
  
	return tx.Commit().Error
  }

10、完整代码：

package main

import (
	"fmt"

	"github/jinzhu/gorm"
	_ "github/jinzhu/gorm/dialects/mysql"
	_ "github/spaolacci/murmur3"
)

type Like struct {
	ID    int    `gorm:"type:int(255);not null"`
	Ip    string `gorm:"type:varchar(20);not null;index:ip_idx"`
	Ua    string `gorm:"type:varchar(256);not null;"`
	Title string `gorm:"type:varchar(128);not null;index:title_idx"`
	Hash  uint64 `gorm:"unique_index:not null;"`
	//CreatedAt time.Time
}

func main() {
	//连接数据库
	db, err := gorm.Open("mysql", "root:543883@(127.0.0.1:3306)/db1?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		panic(err)
	}
	db.DB().SetMaxIdleConns(10)
	fmt.Println("连接成功！")
	defer db.Close()
	//创建新表Like
	if !db.HasTable(&Like{}) {
		if err := db.Set("gorm:table_options", "ENGINE=InnoDB DEFAULT CHARSET=utf8").CreateTable(&Like{}).Error; err != nil {
			panic(err)
		}
	}
	/*
		//插入数据
		like := &Like{
			Ip:    "123",
			Ua:    "111",
			Title: "gorm",
			Hash:  murmur3.Sum64([]byte(strings.Join([]string{"123", "111", "gorm"}, "-"))) >> 1,
			//CreatedAt: time.Now(),
		}
		if err := db.Create(like).Error; err != nil {
			fmt.Println("插入失败！", err)
			return
		} else {
			fmt.Println("插入成功！")
		}
	*/
	/*
		//删除（通过数据表中的Ip值进行删除）
		if err := db.Where(&Like{Hash: 5865620638683223010}).Delete(Like{}).Error; err != nil {
			fmt.Println("删除失败！", err)
			return
		} else {
			fmt.Println("删除成功！")
		}*/
	//查询
	/*
		var count int
		if err := db.Model(&Like{}).Where(&Like{Ip: "123", Ua: "111", Title: "gorm"}).Count(&count).Error; err != nil {
			fmt.Println("查询失败！", err)
			return
		} else {
			fmt.Println(count)
		}*/
	//修改
	var like Like
	db.Model(&like).Where(&Like{Ip: "hello"}).Updates(Like{Ip: "nihao", Ua: "222"}) //将ip为world，ua改为123
}
func CreateAnimals(db *gorm.DB) error {
	//事务一旦开始，你就应该使用 tx 处理数据
	tx := db.Begin()
	defer func() {
		if r := recover(); r != nil {
			tx.Rollback()
		}
	}()

	if err := tx.Error; err != nil {
		return err
	}

	if err := tx.Create(&Like{Ip: "Giraffe"}).Error; err != nil {
		tx.Rollback()
		return err
	}

	if err := tx.Create(&Like{Ip: "Lion"}).Error; err != nil {
		tx.Rollback()
		return err
	}

	return tx.Commit().Error
}

参考文章：

感谢博主的文章另外受益匪浅：(6条消息) 进击的小猿的博客_CSDN博客-Android基础,Python基础,Android控件实例领域博主

Go基础 · Go语言中文文档 (topgoer)

事务 | 教程 |《GORM 中文文档 v2》| Go 技术论坛 (learnku)

更多推荐

使用GORM操作数据库

使用GORM操作数据库

两万字长文，手把手带你走进GORM框架！

一、下载PG数据库（Windows）

1、下载安装pgsql

2、下载安装redis（暂时用不上）

二、Go连接PG数据库

z、\*

a、建库：

b、入库

c、建表：

d、查询：

e、插入：

f、删除：

1、方法1：使用pq包连接

（1）在src目录下，获取包

（2）下载库管理依赖包go.mod：

（3）下载go.sum:

（4）导入依赖包github/lib/pq@latest：

（5）回到VScode使用连接代码：

（7）输出连接成功：

（8）总结1：

2、查询

（1）、查询全部信息：

（2）查询单个信息：

3、插入

4、修改

5、删除

三、进阶：使用GORM框架连接操作数据库

（0）创建数据库（MySQL语法）：

（1）建立连接：

（2）进行表操作

（3）增

（4）查

（5）改

（6）删

（7）总结2

四、官方示例

1、导入包:

2、创建表名和表结构

3、连接数据库

4、创建likes数据表

5、插入

6、删除：

7、查询

8、修改

9、 事务：

10、完整代码：

相关文章

发布评论取消回复

最近发表

热门文章

标签列表

9、事务：