sql数据库连接

前言

作为数据存储的数据库，近年来发展飞快，在早期的程序自我存储到后面的独立出中间件服务，再到集群，不可谓不快了。早期的sql数据库一枝独秀，到后面的Nosql，还有azure安全，五花八门，教人学不过来阿。

一、mysql数据库的golang操作

针对数据库操作，往往需要安装实体数据库和对应的数据库驱动，前者要实际安装配置，可参考菜鸟官网的mysql安装，后者则是下载安装第三方库即可。

jam@jam:~$ mysql -h127.0.0.1 -ujam -p
Enter password:
Welcome to the MySQL monitor.  Commands end with ; or \g.
Your MySQL connection id is 13
Server version: 8.0.33 MySQL Community Server - GPL

Copyright (c) 2000, 2023, Oracle and/or its affiliates.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| performance_schema |
| somedb             |
+--------------------+
3 rows in set (0.00 sec)

mysql> use somedb;
Database changed
mysql> show tables;
Empty set (0.01 sec)

mysql>

这边已经准备好了本地数据库实体，也添加了somedb数据库和对应的jam用户，供golang的调用操作练习。

1.1 database/sql使用

用golang的database/sql接口来进行sql硬编码，后续得到的结果自己硬解码，不过golang需要下载数据库驱动go get github.com/go-sql-driver/mysql，下载好了以后，就是编写sql语句和定流程的事了。

大致程序流程就是连接数据库，调用exec类api来执行sql语句，在python用pymysql等第三方库操作的时候，还需要在插入和更新表数据的时候来个commit，golang倒是不用，就直接Exec，具体如下：

const (
	USERNAME = "jam"
	PWD      = "abaaba"
	NETWORK  = "tcp"
	SERVER   = "127.0.0.1"
	PORT     = 3306
	DATABASE = "somedb"
)

type Student struct {
	Id   int
	Name string
}

func main() {
	conn := fmt.Sprintf("%s:%s@%s(%s:%d)/%s", USERNAME, PWD, NETWORK, SERVER, PORT, DATABASE)
	db, err := sql.Open("mysql", conn)
	if err != nil {
		fmt.Println("mysql数据库连接失败：", err)
		return
	}
	//设置连接存活时间
	db.SetConnMaxLifetime(60 * time.Second)
	//设置最大连接数
	db.SetMaxOpenConns(10)

	createTable(db)
	insert(db, 1, "小昏")
	insert(db, 2, "meiyi")
	insert(db, 3, "明也")
	query_single(db, 1)
	//更新数据
	update(db, 1, "baba")
	all_query(db)
	drop(db)
}

程序主体便是这样，几个执行sql语句根据语义包装成函数分开调用，另外因为用的是IDEA的goland，所以踩了不少的坑，关于数据库在ide中的配置出现了不少warning，有点烦。针对sql中的insert，update，delete操作还是使用db.Exec来对应调用：

// 插入，直接Exec一个sql也行
func insert(db *sql.DB, id int, name string) {
	sql_state, err := db.Prepare("insert into students values (?, ?)")
	res, err := sql_state.Exec(id, name)
	if err != nil {
		fmt.Println("插入失败：", err)
		return
	}
	lastInsertID, _ := res.LastInsertId()
	fmt.Println("插入id：", lastInsertID)
	rowsaffected, _ := res.RowsAffected()
	fmt.Println("affected rows:", rowsaffected)
}

// 修改
func update(db *sql.DB, id int, name string) {
	if res, err := db.Exec("update students set name=? where id=?", name, id); err != nil {
		fmt.Println("更新表失败：", err)
	} else {
		fmt.Println("更新结果：", res)
	}
}

// 删除指定id对应的行
func delete(db *sql.DB, id int) {
	if res, err := db.Exec("delete from students where id=?", id); err != nil {
		fmt.Println("删除失败：", err)
		return
	} else {
		fmt.Println("删除结果：", res)
	}
}

然后针对查询的就用db.Query一类接口：

// 查询一行
func query_single(db *sql.DB, id int) {
	student := new(Student)
	row := db.QueryRow("select * from students where id=?", id)
	if err := row.Scan(&student.Id, &student.Name); err != nil {
		fmt.Println("scan失败：", err)
		return
	}
	fmt.Println("第一行数据：", *student)
}

func all_query(db *sql.DB) {
	students := new(Student)
	rows, err := db.Query("select * from students")

	defer func() {
		if rows != nil {
			rows.Close()
		}
	}()
	if err != nil {
		fmt.Println("查询失败：", err)
		return
	}
	for rows.Next() {
		err = rows.Scan(&students.Id, &students.Name)
		if err != nil {
			fmt.Println("scan失败：", err)
			return
		}
		fmt.Println("scan successed:", *students)
	}
}

另外还有创建表和删除表的操作，也还是用Exec，因为没返回嘛：

func createTable(db *sql.DB) {
	sql_s := `create table if not exists students (
        id int unsigned not null auto_increment primary key ,
        name varchar(10) not null unique
        )engine=InnoDB default charset=utf8;`
	if _, err := db.Exec(sql_s); err != nil {
		fmt.Println("创表失败：", err)
		return
	}
}

func drop(db *sql.DB) {
	if _, err := db.Exec("drop table students"); err != nil {
		fmt.Println("删表失败：", err)
	}
}

针对包引入部分，代码中是这样：

package main

import (
	"database/sql"
	"fmt"
	"time"

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

但实际中关于golang项目还有不少go modules的设置，这里只是实际记录，不做项目前准备的记录。走完一圈，可以发现database/sql提供的也就只是一个连接和对应的exec执行sql语句的接口，对于专门的coder来说，需要另外兼顾sql中的语法，未免有点麻烦，所以有了ORM技术--各玩各的。

二、gorm操作mysql

ORM技术，就是让高级语言的代码编辑专注于该语言的语法，而不用去另外理会sql的语义，具体实现就是，用类似c中的struct，cpp中的class，golang中的struct这类存储结构性信息来对接数据库中的关系型数据，中间的转换问题由专门的库负责，python中的是sqlalchemy，golang中目前接触的就是gorm了。

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

在项目中go get一下下载gorm库和对应mysql驱动即可，不同数据库对应不同驱动。

连接一下，然后进行设置：

const (
	Host     = "127.0.0.1"
	User     = "jam"
	Pwd      = "abaaba"
	Port     = 3306
	Net      = "tcp"
	Database = "somedb"
)

//空配置
func main() {
	dst_uri := fmt.Sprintf("%s:%s@%s(%s:%d)/%s", User, Pwd, Net, Host, Port, Database)
	//简单无配置
	//db, err := gorm.Open(mysql.Open(dst_uri), &gorm.Config{})

	//配置mysql驱动
	//db, err := gorm.Open(mysql.New(mysql.Config{
	//	DSN:                       dst_uri,
	//	DefaultStringSize:         256,   //string类型字符串默认长度
	//	DisableDatetimePrecision:  true,  //禁用datetime精度
	//	DontSupportRenameIndex:    true,  //重命名索引时使用删除并新建的方式
	//	DontSupportRenameColumn:   true,  //用change重命名列
	//	SkipInitializeWithVersion: false, //是否根据当前mysql版本自适应配置
	//}), &gorm.Config{})

	//gorm
	db, err := gorm.Open(mysql.New(mysql.Config{
		DSN: dst_uri,
	}), &gorm.Config{
		SkipDefaultTransaction: false,
		NamingStrategy: schema.NamingStrategy{
			SingularTable: true, // 表名复数形式
			TablePrefix:   "t_", //表名前缀
		},
		DisableForeignKeyConstraintWhenMigrating: true, //设置逻辑外键，体现在代码上
	})

	//获取通用数据库对象sql.DB
	sql_db, err := db.DB()
	//设置连接池中空闲连接的最大数量
	sql_db.SetMaxIdleConns(10)
	//设置打开数据库连接的最大数
	sql_db.SetConnMaxLifetime(time.Hour)
	fmt.Println(sql_db, err)
}

建表

//通过自动迁移来建表，说白了就是提供好golang中的数据结构，然后调用接口给gorm就行，转换的问题交给gorm了
func auto_migrate(db *gorm.DB) {
	type book struct {
		id    int
		name  string
		price float32
	}

	err := db.AutoMigrate(&book{})
	if err != nil {
		fmt.Println(err)
	}
}

//手动迁移的方式建表
func migrate(db *gorm.DB) {
	type view struct {
		Id   int
		Name string
	}

	m := db.Migrator()
	if !m.HasTable(&view{}) {
		m.CreateTable(&view{})
	} else {
		fmt.Println("已存在同名表")
	}
}

测试了一下，自动迁移的方式会针对同名表的创建有个判断，判断同名表是否存在的步骤，其实自动迁移的实现就是内部调用了Migrator接口的一个方法：

func (db *DB) AutoMigrate(dst ...interface{}) error {
	return db.Migrator().AutoMigrate(dst...)
}
// Migrator migrator interface
type Migrator interface {
	//下一小节
}

记，作为gorm的golang结构体的构造，内部成员名要大写开头

后续操作，也是基于Migrator这个接口的基础，因为它有许多方法：

        ...
        //重命名
	m := db.Migrator()
	type view2 struct {
		Id   int
		Name string
	}
	m.RenameTable(&view{}, &view2{})
	fmt.Println("是否存在view2：", m.HasTable(&view2{}))
	m.RenameTable(&view2{}, "view3")

	type view3 struct {
		Id   int
		Name string
	}
        //删表
        m.DropTable(&view3{})
	fmt.Println("是否存在表view3：", m.HasTable(&view3{}))

插入，更新，删除，查询操作

        ...
	type view struct {
		Id   int
		Name string
	}
	type book struct {
		Id    int
		Name  string
		Price float32
	}

	//插入
	views := []view{{1, "wind"}, {2, "rain"}}
	db.Create(&views)
	//查询, 获取第一条记录，并且更新
	v := new(View)
	db.First(&v)
	fmt.Println(v.Id, v.Name)
	//更新
	v.Id = 4
	v.Name = "river"
	db.Save(&v)
	//再查找然后删除表记录
	db.Where("id=?", 3).Delete(&View{})

差不多就这样，更多api可以查看官方中文文档

另外，除了上面的mysql以外，还可以连接本地的sqlite数据库，下载对应驱动就行，也验证了上面的一个说法。