施坤的博客
0%

go 操作mysql

发表于 更新于 分类于 阅读次数： Valine：

说明

  • 对mysql的操作采用了两种，第一种是写原生sql，使用如下两个库
1
2
"github.com/go-sql-driver/mysql"
"github.com/jmoiron/sqlx"
  • 第二种采用orm，使用了如下库
1
2
"gorm.io/driver/mysql"
"gorm.io/gorm"

准备工作

  • 本地搭建好mysql环境，数据库和表名如下

image-20230608170552494

原生sql

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
# hello_work/tmysql/operateMsql.go
package tmysql

import (
	"fmt"

	_ "github.com/go-sql-driver/mysql"
	"github.com/jmoiron/sqlx"
)

//go get github.com/go-sql-driver/mysql
//go get github.com/jmoiron/sqlx

// 对应Class表中的字段
type Class1 struct {
	Id   int    `db:"id"` // 注意这里``的用法，对应数据库的字段
	Name string `db:"name"`
    	Sex  *string `db:"sex"` // 表中数据为空，直接取值报错，若是指针则返回nil

}

var Db *sqlx.DB

func InitDb() {
	database, err := sqlx.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test")
	if err != nil {
		fmt.Println("connect mysql err", err)
		return
	}
	Db = database
}

func Select() {

	var class1 []Class1
	err := Db.Select(&class1, "select id,name,sex from class")
	if err != nil {
		fmt.Println("select error", err)
		return
	}
	fmt.Println("class succ", class1)
	for _, v := range class1 {
		fmt.Println(v.Id)
		fmt.Println(v.Name)
        if v.Sex != nil {
			fmt.Println(*v.Sex)

		}
	}
}

func Insert() {
	r, err := Db.Exec("insert into class(name) values(?)", "三年级一班")
	if err != nil {
		fmt.Println(err)
		return
	}
	id, err := r.LastInsertId()
	if err != nil {
		fmt.Print("exec failed", err)
		return
	}
	fmt.Println("insert success", id)
}

func Update() {
	res, err := Db.Exec("update class set name=? where id=?", "三年级二班", 9)
	if err != nil {
		fmt.Println(err)
		return
	}
	row, err := res.RowsAffected()
	if err != nil {
		fmt.Println("row failed, error", err)
	}
	fmt.Println("update success:", row)
}

func Delete() {
	res, err := Db.Exec("delete from class  where id=?", 10)
	if err != nil {
		fmt.Println(err)
		return
	}
	row, err := res.RowsAffected()
	if err != nil {
		fmt.Println("row failed, error", err)
	}
	fmt.Println("detele success:", row)

}

  • 代码调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
# hello_work/main.go
package main

import (
	"example.com/hello_work/hello_work/tmysql"
)

func main() {
	tmysql.InitDb()
	tmysql.Select()
	tmysql.Insert()
	tmysql.Update()
	tmysql.Delete()
}

gorm

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
package ggorm

import (
	"fmt"

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

// 安装gorm
//go get gorm.io/gorm
// 安装mysql驱动
//go get gorm.io/driver/mysql

var Db *gorm.DB

type User struct {
	gorm.Model      // 内置的结构提
	Id         uint // 默认为主键
	Name       string
}

func InitDb() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local"
	database, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	// database, err := gorm.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local")
	if err != nil {
		fmt.Println("open mysql error:", err)
	}
	Db = database
	//// 根据User结构体，自动创建表结构,表名为users,如果表存在，不会创建
	Db.AutoMigrate(&User{})
}
func Close() {
	sqlDB, _ := Db.DB()
	sqlDB.Close()
}

func Insert() {
	u := User{
		Name: "张山1",
	}

	if err := Db.Create(&u).Error; err != nil {
		fmt.Println("create is wrong,error:", err)
		return
	}
	fmt.Println("创建数据成功")
}

func Select() {
	var users []User
	// SELECT * FROM users;
	if err := Db.Find(&users).Error; err != nil {
		fmt.Println("find failed, error:", err)
		return
	}
	for k, v := range users {
		fmt.Println("k=", k, "v=", v)
		fmt.Println(v.Name)
		fmt.Println(v.Id)
	}
	//SELECT * FROM users WHERE name = '张山1';
	Db.Where("name=?", "张山1").Find(&users)
	if len(users) == 0 {
		fmt.Println("find failed")
		return
	}

	for k, v := range users {
		fmt.Println("k1=", k, "v1=", v)
		fmt.Println(v.Name)
		fmt.Println(v.Id)
	}

}

func Update() {
	user := &User{Id: 1}
	d := Db.Model(user).Update("Name", "lisi")
	if d.Error != nil {
		fmt.Println("update failed")
		return
	}
	fmt.Println("update success")
}

func Detele() {
	user := &User{Id: 2}
    
// 查询不到此数据，就说明无法删除
	var users []User
	Db.Where("id=?", 2).Find(&users)
	if len(users) == 0 {
		fmt.Println("del failed")
		return
	}
	// 永久删除
	d := Db.Unscoped().Delete(&user)
	// 下面的语句有问题无论删除是否成功都成功
	if d.Error != nil {
		fmt.Println("del failed")
		return
	}
	
	fmt.Println("del success")
}

  • 代码调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# hello_work/main.go
package main

import (
	"example.com/hello_work/hello_work/ggorm"
	"example.com/hello_work/hello_work/tmysql"
)

func main() {
	tmysql.InitDb()
	tmysql.Select()
	tmysql.Insert()
	tmysql.Update()
	tmysql.Delete()

	ggorm.InitDb()
	ggorm.Insert()
	ggorm.Update()
	ggorm.Detele()
	ggorm.Close()
}

来自