Go语言使用sqlx操作MySQL_Golang

go 语言以其高效和简洁的语法逐渐受到开发者的青睐。在实际开发中，数据库操作是不可避免的任务之一。虽然标准库提供了 database/sql 包来支持数据库操作，但使用起来略显繁琐。

sqlx 包作为一个扩展库，它在 database/sql 的基础上，提供了更高级别的便利，极大地简化了数据库操作。本文章将介绍如何通过 github.com/jmoiron/sqlx 包来操作 mysql 数据库。

准备工作

首先，确保你的 go 环境已经搭建完毕，并且 mysql 数据库已安装并正在运行。接下来，安装 sqlx 包及 mysql 驱动：

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

连接 mysql 数据库

在使用数据库之前，我们需要建立与 mysql 的连接。在 go 语言中，通常使用一个连接字符串来指定数据库的一些信息。以下是一个示例代码，演示如何连接 mysql 数据库：

package main

import (
	"fmt"

	_ "github.com/go-sql-driver/mysql" // 一定不能忘记导入数据库驱动
	"github.com/jmoiron/sqlx"
)

var db *sqlx.db

type user struct {
	id   int64  `db:"id"`
	name string `db:"name"`
	age  int    `db:"age"`
}

func initdb() (err error) {
	dsn := "root:123456@tcp(127.0.0.1:3306)/sql_test?charset=utf8mb4&parsetime=true"
	// 也可以使用 mustconnect 连接不成功就直接 panic
	// db = sqlx.mustconnect("mysql", dsn)
	db, err = sqlx.connect("mysql", dsn)
	if err != nil {
		fmt.printf("connect db failed, err:%v\n", err)
		return
	}
	db.setmaxopenconns(20) // 设置数据库连接池的最大连接数
	db.setmaxidleconns(10) // 设置数据库连接池的最大空闲连接数
	return
}

在这个例子中，请替换为你自己的mysql 配置。

数据库操作

1. 创建表

接下来，让我们创建一个示例表。我们可以使用 exec 方法执行 sql 语句来创建表。

func createtable(db *sqlx.db) (err error) {
	// 写sql语句
	sqlstr := `create table if not exists users (
		id bigint primary key auto_increment,
		name varchar(20),
		age int default 1
	);`
	_, err = db.exec(sqlstr)

	return err
}

在 main 函数中调用 createtable(db)，以确保在连接后创建表。

2. 插入数据

// 插入用户并获取 id
func insertuser(db *sqlx.db, name string, age int) (int64, error) {
	result, err := db.exec("insert into users(name, age) values(?, ?)", name, age)
	if err != nil {
		return 0, err
	}

	id, err := result.lastinsertid()
	if err != nil {
		return 0, err
	}
	return id, nil
}

3. 查询数据

// 查询单条用户记录
func getuser(db *sqlx.db, id int64) (*user, error) {
	var user user
	err := db.get(&user, "select * from users where id=?", id)
	if err != nil {
		return nil, err
	}
	return &user, nil
}

// 查询所有用户记录
func getallusers(db *sqlx.db, id int64) ([]user, error) {
	var users []user
	err := db.select(&users, "select * from users where id > ?", id)
	if err != nil {
		return nil, err
	}
	return users, nil
}

4. 更新数据

// 更新用户信息
func updateuser(db *sqlx.db, id int64, name string, age int) (int64, error) {
	result, err := db.exec("update users set name=?, age=? where id=?", name, age, id)
	if err != nil {
		return 0, err
	}
	rowsaffected, err := result.rowsaffected()
	if err != nil {
		return 0, err
	}
	return rowsaffected, nil
}

5. 删除数据

// 删除用户记录
func deleteuser(db *sqlx.db, id int64) (int64, error) {
	result, err := db.exec("delete from users where id=?", id)
	if err != nil {
		return 0, err
	}
	rowsaffected, err := result.rowsaffected()
	if err != nil {
		return 0, err
	}
	return rowsaffected, nil
}

6. 使用命名参数来操作

// 使用命名参数插入用户
func insertusernamed(db *sqlx.db, name string, age int) (int64, error) {
	query := `insert into users(name, age) values(:name, :age)`
	result, err := db.namedexec(query, map[string]interface{}{
		"name": name,
		"age":  age,
	})
	if err != nil {
		return 0, err
	}
	id, err := result.lastinsertid()
	if err != nil {
		return 0, err
	}
	return id, nil
}

// 使用命名参数查询用户
func getusersnamed(db *sqlx.db, name string) ([]user, error) {
	query := `select * from users where name = :name`
	var users []user
	rows, err := db.namedquery(query, map[string]interface{}{
		"name": name,
	})
	if err != nil {
		return nil, err
	}
	defer rows.close()
	for rows.next() {
		var user user
		err := rows.structscan(&user)
		if err != nil {
			fmt.printf("scan failed, err:%v\n", err)
			continue
		}
		users = append(users, user)
	}

	return users, nil
}

7. 测试一下代码

func run() {
	// 初始化数据库
	err := initdb()
	if err != nil {
		fmt.printf("init db failed, err:%v\n", err)
		return
	}
	defer db.close() // 注意这行代码要写在上面err判断的下面

	// 创建表
	err = createtable(db)
	if err != nil {
		fmt.printf("create table failed, err:%v\n", err)
		return
	}

	// 插入数据
	id, err := insertuser(db, "alex", 18)
	if err != nil {
		fmt.printf("insert user failed, err:%v\n", err)
		return
	}
	fmt.println("insert success, the id is:", id)

	// 查询单条数据
	user, err := getuser(db, id)
	if err != nil {
		fmt.printf("get user failed, err:%v\n", err)
		return
	}

	fmt.printf("user:%#v\n", user)

	// 查询多条数据
	users, err := getallusers(db, 0)
	if err != nil {
		fmt.printf("get all users failed, err:%v\n", err)
		return
	}

	fmt.printf("users:%#v\n", users)

	// 更新数据
	rowsaffected, err := updateuser(db, id, "alex", 20)
	if err != nil {
		fmt.printf("update user failed, err:%v\n", err)
		return
	}

	fmt.println("update success, affected rows:", rowsaffected)

	// 删除数据
	rowsaffected, err = deleteuser(db, id)
	if err != nil {
		fmt.printf("delete user failed, err:%v\n", err)
		return
	}

	fmt.println("delete success, affected rows:", rowsaffected)

	// 使用命名参数插入数据
	id, err = insertusernamed(db, "alex", 19)
	if err != nil {
		fmt.printf("insert user named failed, err:%v\n", err)
		return
	}

	fmt.println("insert named success, the id is:", id)

	// 使用命名参数查询数据
	users, err = getusersnamed(db, "alex")
	if err != nil {
		fmt.printf("get users named failed, err:%v\n", err)
		return
	}

	fmt.printf("users named:%#v\n", users)

	fmt.println("exec sql success")
}

我们可以看到，使用 sqlx 还是要比 database/sql 要简洁许多。