MySQL

package main

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

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

func main() {
	// mysql -p
	// create database practice
	dsn := "root:123456@tcp(127.0.0.1:3306)/practice"
	db, err := sql.Open("mysql", dsn)
	/*
		这个db结构是一个数据库句柄，代表一个具有0到多个底层连接的连接池。可以安全被多个go协程同时使用。go的sql包会自动创建和释放连接：它会维护一个闲置连接的连接池。
	*/
	if err != nil {
		panic(err)
	}
	if err = db.Ping(); err != nil {
		panic(err)
	}
	fmt.Println("connect mysql success")
	db.SetMaxOpenConns(5) // 最大连接条数==5
	/* 查询一行 */
	rows := db.QueryRow("select val from gap where id = ?", 10828) // 获取一条连接
	var v int
	rows.Scan(&v) // 这个操作会释放连接，但是不是真的释放连接，而是标识这条连接是空闲的
	fmt.Println("v:", v)

	/* 用来测试设置的最大连接数 */
	// for i := 0; i < 6; i++ {
	// 	fmt.Println("i=", i)
	// 	db.QueryRow("select val from gap where id = ?", 10828) // 因为我们只query了但是没有使用scan释放连接，当获取第6条连接时，会阻塞在这里
	// }

	/* 查询多行 */
	rows2, err := db.Query("select * from gap")
	if err != nil {
		log.Fatal(err)
	}
	defer rows2.Close() // 确保安全，因为万一遍历过程中出错了，会导致连接没有释放
	for rows2.Next() {  // next这个函数，在所有都遍历过后才会去释放连接
		var i, val int
		rows2.Scan(&i, &val)
		fmt.Println("i=", i, ",v=", val)
	}

	/* 插入数据 */
	res, err := db.Exec("insert into gap (val) values (?)", rand.Intn(1000)) // 这个会释放连接
	if err != nil {
		log.Fatal(err)
	}
	idx, _ := res.LastInsertId()
	affects, _ := res.RowsAffected()
	fmt.Println("idx:", idx, ",affr:", affects)

	/* 预编译语句 */
	// 任何时候都要避免手动拼接sql语句，防止sql注入，预编译语句不仅效率高而且能有效防止sql注入
	stmt, err := db.Prepare("select * from gap where id = ?") // 这个会释放连接
	if err != nil {
		log.Fatal(err)
	}
	row3 := stmt.QueryRow(4)
	var id, val int
	row3.Scan(&id, &val)
	fmt.Println("id:", id, ",val:", val)
	stmt0, err := db.Prepare("insert into gap (val) values(?)")
	if err != nil {
		log.Fatal(err)
	}
	for i := 0; i < 10; i++ {
		stmt0.Exec(rand.Intn(1000)) // 非常方便
	}
}

package main

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

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

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/practice?multiStatements=true" // 开启多语句，提高执行效率，引入了sql注入风险
	db, err := sql.Open("mysql", dsn)
	if err != nil {
		panic(err)
	}
	if err = db.Ping(); err != nil {
		panic(err)
	}
	fmt.Println("connect mysql success")
	db.SetMaxOpenConns(5) // 最大连接条数==5

	/* 一次执行多语句，只需要一次网络通信，提高了效率，尽量不要这样做，有sql注入的风险 */
	rows, err := db.Query("select * from gap; select id,age from user;")
	if err != nil {
		log.Fatal(err)
	}
	defer rows.Close()
	for rows.Next() {
		var id, val int
		rows.Scan(&id, &val)
		fmt.Println("id:", id, "val:", val)
	}
	if rows.NextResultSet() { // 多语句的结果取法
		for rows.Next() {
			var id, val int
			rows.Scan(&id, &val)
			fmt.Println("id:", id, "age:", val)
		}
	}
	fmt.Println("ok")

	/*
		在mysql定义一个存储过程叫NewProc，使用存储过程，可以既实现多语句执行提高效率又不用担心sql注入
		begin
			DECLARE i INT DEFAULT NULL;
			insert into `gap` (val) values (num);
			select id into i from `gap` order by id desc limit 9,1;
			if i is NOT NULL then
				delete from gap where id < i;
			end if;
		end
	*/
	res, err := db.Exec("call NewProc(?)", rand.Intn(1000))
	if err != nil {
		log.Fatal(err)
	}
	affects, _ := res.RowsAffected()
	fmt.Println("affects:", affects)
}

package main

import (
	"fmt"
	"log"

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

func main() {
	dsn := "root:123456@tcp(127.0.0.1:3306)/practice"
	db, err := sqlx.Connect("mysql", dsn)
	if err != nil {
		panic(err)
	}
	defer db.Close()
	db.SetMaxOpenConns(10)
	tx, err := db.Beginx()
	if err != nil {
		log.Fatal(err)
	}
	// 加X锁防止幻读
	row := tx.QueryRowx("select id from user where id = ? lock in share mode", 5)
	var id int
	row.Scan(&id)
	if id != 5 {
		fmt.Println("不存在插入数据")
		_, err = tx.Exec("insert into user (id, name, height, sex, age) values (5,'lin', 190, 1, 22)")
		if err != nil {
			tx.Rollback()
			return
		}
	} else {
		fmt.Println("已经存在不插入")
	}
	tx.Commit()
}