Go语言之操作数据库CRUD

package main

import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)

// 定义一个全局对象db
var db *sql.DB
//定义结构体
type User struct {
    Id   int
    Name string
    Age  int
}

//初始化数据库
func InitDB() (err error) {
    //连接数据库
    dsn := "root:root@tcp(127.0.0.1:3306)/db3"
    db, err = sql.Open("mysql", dsn)
    //错误处理
    if err != nil {
        return err
    }
    //检验dsn是否正确
    err = db.Ping()
    if err != nil {
        return err
    }
    return nil
}

//数据库单行查询
func queryRowDemo() {
    //创建User对象
    var u User
    //sql语句
    sqlStr := "select * from user where id=?"
    //调用QueryRow方法返回查询的一行，后边调用的scan方法是将查询出来的行放入指定的参数中
    err := db.QueryRow(sqlStr, 1).Scan(&u.Id, &u.Name, &u.Age)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(u.Id, u.Name, u.Age)
}

//查询多行
/*
查询多行和查询单行的不同之处是调用方法query并返回多行
然后通过for循环调用scan方法吧每一行循环遍历出来
*/
func queryDemo() {
    //sql语句
    sqlStr := "select * from user"
    //调用方法
    rows, err := db.Query(sqlStr)
    //错误处理
    if err != nil {
        fmt.Println(err)
    }
    //关闭rows释放持有的数据库链接
    defer rows.Close()
    //使用for循环进行结果的读取
    for rows.Next() {
        var u User
        err := rows.Scan(&u.Id, &u.Name, &u.Age)
        if err != nil {
            fmt.Println(err)
        }
        fmt.Printf("id:%d name:%s age:%d\n", u.Id, u.Name, u.Age)
    }
}

//插入数据
func InsertDemo() {
    //sql语句
    sqlStr := "insert into user(name,age) value(?,?)"
    //Exec执行一次命令（包括查询、删除、更新、插入等），返回的Result是对已执行的SQL命令的总结。参数args表示query中的占位参数
    ret, err := db.Exec(sqlStr, "赵六", 30)
    if err != nil {
        fmt.Println(err)
        return
    }
    fmt.Println(ret)
    // 新插入数据的id是theID
    theID, err := ret.LastInsertId()
    if err != nil {
        fmt.Printf("get lastinsert ID failed, err:%v\n", err)
        return
    }
    fmt.Printf("insert success, the id is %d.\n", theID)
}

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

//删除数据
func DeleteDemo() {
    sqlStr := "delete from user where id=?"
    ret, err := db.Exec(sqlStr, 4)
    if err != nil {
        fmt.Println(err)
        return
    }
    n, err := ret.RowsAffected()
    if err != nil {
        fmt.Printf("get RowsAffected failed, err:%v\n", err)
        return
    }
    fmt.Printf("delete success, affected rows:%d\n", n)

}
func main() {
    //调用初始化函数
    err := InitDB()
    if err != nil {
        fmt.Println(err)
    }
    //调用函数
    //queryRowDemo()
    //queryDemo()
    //InsertDemo()
    //UpdateDemo()
    //DeleteDemo()
}

 sql预处理：

优化MySQL服务器重复执行SQL的方法，可以提升服务器性能，提前让服务器编译，一次编译多次执行，节省后续编译的成本。

避免SQL注入问题。

查询的sql预处理代码：

//预处理
func prepareSql() {
    var u User
    sqlStr := "select * from user"
    stmt, err := db.Prepare(sqlStr)
    if err != nil {
        fmt.Println(err)
        return
    }
    defer stmt.Close()
    rows, err := stmt.Query()
    if err != nil {
        fmt.Println(err)
        return
    }
    defer rows.Close()
    for rows.Next() {
        err := rows.Scan(&u.Id, &u.Name, &u.Age)
        if err != nil {
            fmt.Println(err)
            return
        }
        fmt.Println(u.Id, u.Name, u.Age)
    }
}

事务：

　　比如，我们去银行转账，操作可以分为下面两个环节：(1)从第一个账户划出款项。 (2)将款项存入第二个账户。 

　　在这个过程中，两个环节是关联的。第一个账户划出款项必须保证正确的存入第二个账户，如果第二个环节没有完成，整个的过程都应该取消，否则就会发生丢失款项的问题。整个交易过程，可以看作是一个事物，成功则全部成功，失败则需要全部撤消，这样可以避免当操作的中间环节出现问题时，产生数据不一致的问题。

事务的特性：

原子性	一个事务（transaction）中的所有操作，要么全部完成，要么全部不完成，不会结束在中间某个环节。事务在执行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
一致性	在事务开始之前和事务结束以后，数据库的完整性没有被破坏。这表示写入的资料必须完全符合所有的预设规则，这包含资料的精确度、串联性以及后续数据库可以自发性地完成预定的工作。
隔离性	数据库允许多个并发事务同时对其数据进行读写和修改的能力，隔离性可以防止多个事务并发执行时由于交叉执行而导致数据的不一致。事务隔离分为不同级别，包括读未提交（Read uncommitted）、读提交（read committed）、可重复读（repeatable read）和串行化（Serializable）。
持久性	事务处理结束后，对数据的修改就是永久的，即便系统故障也不会丢失。

举例：

func transactionDemo() {
    //事务分为 开始事务 提交事务和回滚事务
    //开始事务 当开始一个事务后需要用事务进行操作
    tx, err := db.Begin()
    //出错了 如果有错误就需要进行事务的回滚
    if err != nil {
        if tx != nil {
            tx.Rollback()
        }
        return
    }

    sqlStr := "update user set age=100 where id=?"
    _, err = tx.Exec(sqlStr, 1)
    if err != nil {
        fmt.Println(err)
        tx.Rollback()
        return
    }

    sqlStr1 := "update user set age=101 where id=?"
    _, err = tx.Exec(sqlStr1, 2)
    if err != nil {
        fmt.Println(err)
        tx.Rollback()
        return
    }
    //事务提交
    err=tx.Commit()
    if err!=nil{
        tx.Rollback()
        return
    }

}