golang中的MySQL增删改查

准备测试数据：

1. 创建一个名为test的数据库

CREATE DATABASES test；

2. 使用该数据库:

use test;

3. 新建一个表格：

CREATE TABLE `user` (
    `id` BIGINT(20) NOT NULL AUTO_INCREMENT,
    `name` VARCHAR(20) DEFAULT '',
    `age` INT(11) DEFAULT '0',
    PRIMARY KEY(`id`)
)ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4;

增：

表格中新增一个数据：

使用sql语句：

sql添加数据的语句：

INSERT INTO table_name ( field1, field2,...fieldN )
                       VALUES
                       ( value1, value2,...valueN );

• table_name: 目标对象，数据将会添加到这个表格。
• field: 属性列表，该属性必须是表格中存在的属性。
• value: 属性值列表，属性值列表必须与属性列表顺序对应

在golang中：

增删改查其实都只是将数据和SQL语句传入，基本流程都是差不多的，只是使用的SQL语句和在golang中对应的函数不同。

func insertRow() {
        // sql的插入语句
	sqlStr := "INSERT INTO user(name, age) VALUES (?,?)"
        // 将sql语句与数据同时传入
	if ret, err := db.Exec(sqlStr, "王五", 38); err != nil {
            fmt.Printf("insert failed, err:%v
", err)
	    return
	}
}

查

查询分为单查询和多查询

单查询

// 定义接受数据的结构体
type user struct {
	id   int
	age  int
	name string
}

// 单查询
func queryRow() {
	sqlStr := "select id, name, age from user where id=?"
	var u user
	// 非常重要：确保QueryRow之后调用Scan方法，否则持有的数据库链接不会被释放
	if err := db.QueryRow(sqlStr, 1).Scan(&u.id, &u.name, &u.age); err != nil {
		fmt.Printf("scan failed, err:%v
", err)
		return
	}
	fmt.Printf("id:%d name:%s age:%d
", u.id, u.name, u.age)
}

多查询：

多查询与单查询的差异主要在于结果，单查询的结果返回的是单一结果，而多查询的结果返回的是结果列表，需要使用循环读取所有结果。

func queryMultiRow() {
	sqlStr := "select id, name, age from user where id > ?"
	rows, err := db.Query(sqlStr, 0)
	if err != nil {
		fmt.Printf("query failed, err:%v
", err)
		return
	}
	// 非常重要：关闭rows释放持有的数据库链接
	defer rows.Close()

	// 循环读取结果集中的数据
	for rows.Next() {
		var u user
		err := rows.Scan(&u.id, &u.name, &u.age)
		if err != nil {
			fmt.Printf("scan failed, err:%v
", err)
			return
		}
		fmt.Printf("id:%d name:%s age:%d
", u.id, u.name, u.age)
	}
}

改

func updateRow() {
	sqlStr := "update user set age=? where id = ?"
	ret, err := db.Exec(sqlStr, 39, 3)
	if err != nil {
		fmt.Printf("update failed, err:%v
", err)
		return
	}
	n, err := ret.RowsAffected() // 操作影响的行数
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v
", err)
		return
	}
	fmt.Printf("update success, affected rows:%d
", n)
}

删

func deleteRow() {
	sqlStr := "delete from user where id = ?"
	ret, err := db.Exec(sqlStr, 3)
	if err != nil {
		fmt.Printf("delete failed, err:%v
", err)
		return
	}
	n, err := ret.RowsAffected() // 操作影响的行数
	if err != nil {
		fmt.Printf("get RowsAffected failed, err:%v
", err)
		return
	}
	fmt.Printf("delete success, affected rows:%d
", n)
}

总结：

总的来说，数据库的增删改查并不难，前提是对于sql语句的增删改查本身有所了解