Go笔记-数据库

时间  2021-02-26
标签 mysql git github golang sql 数据库 缓存 tcp ide 函数 栏目 SQL 繁體版
原文   原文链接

参考资料

链接

mysql

name:password@tcp(ip:3306)/dbname?charset=utf8&loc=Local

ipv6:mysql

user:password@tcp([hostname]:port)/dbname

SQLInterface

https://github.com/golang/go/wiki/SQLInterfacegit

Introduction

The database/sql package provides a generic interface around SQL (or SQL-like) databases. See the official documentation for details.github

This page provides example usage patterns.golang

Database driver

The database/sql package must be used in conjunction with a database driver. See http://golang.org/s/sqldrivers for a list of drivers.sql

The documentation below assumes a driver has been imported.数据库

Connecting to a database

Open is used to create a database handle:缓存

db, err := sql.Open(driver, dataSourceName)

Where driver specifies a database driver and dataSourceName specifies database-specific connection information such as database name and authentication credentials.tcp

Note that Open does not directly open a database connection: this is deferred until a query is made. To verify that a connection can be made before making a query, use the Ping function:ide

if err := db.Ping(); err != nil {
  log.Fatal(err)
}

After use, the database is closed using Close.函数

Executing queries

Exec is used for queries where no rows are returned:

result, err := db.Exec(
    "INSERT INTO users (name, age) VALUES ($1, $2)",
    "gopher",
    27,
)

Where result contains the last insert ID and number of rows affected. The availability of these values is dependent on the database driver.

Query is used for retrieval:

rows, err := db.Query("SELECT name FROM users WHERE age = $1", age)
if err != nil {
    log.Fatal(err)
}
for rows.Next() {
    var name string
    if err := rows.Scan(&name); err != nil {
        log.Fatal(err)
    }
    fmt.Printf("%s is %d\n", name, age)
}
if err := rows.Err(); err != nil {
    log.Fatal(err)
}

QueryRow is used where only a single row is expected:

var age int64
row := db.QueryRow("SELECT age FROM users WHERE name = $1", name)
err := row.Scan(&age)

Prepared statements can be created with Prepare:

age := 27
stmt, err := db.Prepare("SELECT name FROM users WHERE age = $1")
if err != nil {
    log.Fatal(err)
}
rows, err := stmt.Query(age)
// process rows

Exec, Query and QueryRow can be called on statements. After use, a statement should be closed with Close.

Transactions

Transactions are started with Begin:

tx, err := db.Begin()
if err != nil {
    log.Fatal(err)
}

The Exec, Query, QueryRow and Prepare functions already covered can be used in a transaction.

A transaction must end with a call to Commit or Rollback.

Dealing with NULL

If a database column is nullable, one of the types supporting null values should be passed to Scan.

For example, if the name column in the names table is nullable:

var name NullString
err := db.QueryRow("SELECT name FROM names WHERE id = $1", id).Scan(&name)
...
if name.Valid {
    // use name.String
} else {
    // value is NULL
}

Only NullBool, NullFloat64, NullInt64 and NullString are implemented in database/sql. Implementations of database-specific null types are left to the database driver.

批量操做各类方式效率分析

package main

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

var db = &sql.DB{}

func init(){
    db,_ = sql.Open("mysql", "root:root@/book")
} 

func main() {
    insert()
    query()
    update()
    query()
    delete()
}

func update(){
    //方式1 update
    start := time.Now()
    for i := 1001;i<=1100;i++{
        db.Exec("UPdate user set age=? where uid=? ",i,i)
    }
    end := time.Now()
    fmt.Println("方式1 update total time:",end.Sub(start).Seconds())
    
    //方式2 update
    start = time.Now()
    for i := 1101;i<=1200;i++{
        stm,_ := db.Prepare("UPdate user set age=? where uid=? ")
        stm.Exec(i,i)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 update total time:",end.Sub(start).Seconds())
    
    //方式3 update
    start = time.Now()
    stm,_ := db.Prepare("UPdate user set age=? where uid=?")
    for i := 1201;i<=1300;i++{
        stm.Exec(i,i)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 update total time:",end.Sub(start).Seconds())
    
    //方式4 update
    start = time.Now()
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        tx.Exec("UPdate user set age=? where uid=?",i,i)
    }
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 update total time:",end.Sub(start).Seconds())
    
    //方式5 update
    start = time.Now()
    for i := 1401;i<=1500;i++{
        tx,_ := db.Begin()
        tx.Exec("UPdate user set age=? where uid=?",i,i)
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 update total time:",end.Sub(start).Seconds())
    
    // 方式1 update total time: 7.3394198
	// 方式2 update total time: 7.8464488
	// 方式3 update total time: 6.0053435
	// 方式4 update total time: 0.6630379000000001
	// 方式5 update total time: 4.5402597
    
}

func delete(){
    //方式1 delete
    start := time.Now()
    for i := 1001;i<=1100;i++{
        db.Exec("DELETE FROM USER WHERE uid=?",i)
    }
    end := time.Now()
    fmt.Println("方式1 delete total time:",end.Sub(start).Seconds())
    
    //方式2 delete
    start = time.Now()
    for i := 1101;i<=1200;i++{
        stm,_ := db.Prepare("DELETE FROM USER WHERE uid=?")
        stm.Exec(i)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 delete total time:",end.Sub(start).Seconds())
    
    //方式3 delete
    start = time.Now()
    stm,_ := db.Prepare("DELETE FROM USER WHERE uid=?")
    for i := 1201;i<=1300;i++{
        stm.Exec(i)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 delete total time:",end.Sub(start).Seconds())
    
    //方式4 delete
    start = time.Now()
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        tx.Exec("DELETE FROM USER WHERE uid=?",i)
    }
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 delete total time:",end.Sub(start).Seconds())
    
    //方式5 delete
    start = time.Now()
    for i := 1401;i<=1500;i++{
        tx,_ := db.Begin()
        tx.Exec("DELETE FROM USER WHERE uid=?",i)
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 delete total time:",end.Sub(start).Seconds())
    
    // 方式1 delete total time: 3.8652211000000003
	// 方式2 delete total time: 3.8582207
	// 方式3 delete total time: 3.6972114
	// 方式4 delete total time: 0.43202470000000004
	// 方式5 delete total time: 3.7972172
    
}

func query(){
    
    //方式1 query
    start := time.Now()
    rows,_ := db.Query("SELECT uid,username FROM USER")
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
        //fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end := time.Now()
    fmt.Println("方式1 query total time:",end.Sub(start).Seconds())
    
    //方式2 query
    start = time.Now()
    stm,_ := db.Prepare("SELECT uid,username FROM USER")
    defer stm.Close()
    rows,_ = stm.Query()
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
       // fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end = time.Now()
    fmt.Println("方式2 query total time:",end.Sub(start).Seconds())
    
    
    //方式3 query
    start = time.Now()
    tx,_ := db.Begin()
    defer tx.Commit()
    rows,_ = tx.Query("SELECT uid,username FROM USER")
    defer rows.Close()
    for rows.Next(){
         var name string
         var id int
        if err := rows.Scan(&id,&name); err != nil {
            log.Fatal(err)
        }
        //fmt.Printf("name:%s ,id:is %d\n", name, id)
    }
    end = time.Now()
    fmt.Println("方式3 query total time:",end.Sub(start).Seconds())
    
	// 方式1 query total time: 0.0070004
	// 方式2 query total time: 0.0100006
	// 方式3 query total time: 0.0100006
}

func insert() {
    
    //方式1 insert
    //strconv,int转string:strconv.Itoa(i)
    start := time.Now()
    for i := 1001;i<=1100;i++{
        //每次循环内部都会去链接池获取一个新的链接，效率低下
        db.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
    }
    end := time.Now()
    fmt.Println("方式1 insert total time:",end.Sub(start).Seconds())
    
    //方式2 insert
    start = time.Now()
    for i := 1101;i<=1200;i++{
        //Prepare函数每次循环内部都会去链接池获取一个新的链接，效率低下
        stm,_ := db.Prepare("INSERT INTO user(uid,username,age) values(?,?,?)")
        stm.Exec(i,"user"+strconv.Itoa(i),i-1000)
        stm.Close()
    }
    end = time.Now()
    fmt.Println("方式2 insert total time:",end.Sub(start).Seconds())
    
    //方式3 insert
    start = time.Now()
    stm,_ := db.Prepare("INSERT INTO user(uid,username,age) values(?,?,?)")
    for i := 1201;i<=1300;i++{
        //Exec内部并无去获取链接，为何效率仍是低呢？
        stm.Exec(i,"user"+strconv.Itoa(i),i-1000)
    }
    stm.Close()
    end = time.Now()
    fmt.Println("方式3 insert total time:",end.Sub(start).Seconds())
    
    //方式4 insert
    start = time.Now()
    //Begin函数内部会去获取链接
    tx,_ := db.Begin()
    for i := 1301;i<=1400;i++{
        //每次循环用的都是tx内部的链接，没有新建链接，效率高
        tx.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
    }
    //最后释放tx内部的链接
    tx.Commit()
    
    end = time.Now()
    fmt.Println("方式4 insert total time:",end.Sub(start).Seconds())
    
    //方式5 insert
    start = time.Now()
    for i := 1401;i<=1500;i++{
        //Begin函数每次循环内部都会去链接池获取一个新的链接，效率低下
        tx,_ := db.Begin()
        tx.Exec("INSERT INTO user(uid,username,age) values(?,?,?)",i,"user"+strconv.Itoa(i),i-1000)
        //Commit执行后链接也释放了
        tx.Commit()
    }
    end = time.Now()
    fmt.Println("方式5 insert total time:",end.Sub(start).Seconds())
    
    // 方式1 insert total time: 3.7952171
	// 方式2 insert total time: 4.3162468
	// 方式3 insert total time: 4.3392482
	// 方式4 insert total time: 0.3970227
	// 方式5 insert total time: 7.3894226
}

database/sql接口

Go没有官方提供数据库驱动，而是为开发者开发数据库驱动定义了一些标准接口。

sql.Register

这个存在于database/sql的函数是用来注册数据库驱动的，当第三方开发者开发数据库驱动时，都会实现init函数，在init里面会调用这个Register(name string, driver driver.Driver)完成本驱动的注册。

咱们来看一下mymysql、sqlite3的驱动里面都是怎么调用的：

//https://github.com/mattn/go-sqlite3驱动
func init() {
    sql.Register("sqlite3", &SQLiteDriver{})
}

//https://github.com/mikespook/mymysql驱动
// Driver automatically registered in database/sql
var d = Driver{proto: "tcp", raddr: "127.0.0.1:3306"}
func init() {
    Register("SET NAMES utf8")
    sql.Register("mymysql", &d)
}

在database/sql内部经过一个map来存储用户定义的相应驱动。

var drivers = make(map[string]driver.Driver)
drivers[name] = driver

引用第三方库示例：

import (
      "database/sql"
      _ "github.com/mattn/go-sqlite3"
  )

其中，_ 就是为了调用包的init函数。

driver.Driver

Driver是一个数据库驱动的接口，他定义了一个method： Open(name string)，这个方法返回一个数据库的Conn接口。

type Driver interface {
    Open(name string) (Conn, error)
}

返回的Conn只能用来进行一次goroutine的操做，也就是说不能把这个Conn应用于Go的多个goroutine里面。以下代码会出现错误

// ...
go goroutineA (Conn)  //执行查询操做
go goroutineB (Conn)  //执行插入操做
// ...

上面这样的代码可能会使Go不知道某个操做到底是由哪一个goroutine发起的,从而致使数据混乱，好比可能会把goroutineA里面执行的查询操做的结果返回给goroutineB从而使B错误地把此结果当成本身执行的插入数据。

第三方驱动都会定义这个函数，它会解析name参数来获取相关数据库的链接信息，解析完成后，它将使用此信息来初始化一个Conn并返回它。

driver.Conn

Conn是一个数据库链接的接口定义，他定义了一系列方法，这个Conn只能应用在一个goroutine里面，不能使用在多个goroutine里面。

type Conn interface {
    Prepare(query string) (Stmt, error)
    Close() error
    Begin() (Tx, error)
}

Prepare函数返回与当前链接相关的执行Sql语句的准备状态，能够进行查询、删除等操做。

Close函数关闭当前的链接，执行释放链接拥有的资源等清理工做。由于驱动实现了database/sql里面建议的conn pool，因此你不用再去实现缓存conn之类的，这样会容易引发问题。

Begin函数返回一个表明事务处理的Tx，经过它你能够进行查询,更新等操做，或者对事务进行回滚、递交。

driver.Stmt

Stmt是一种准备好的状态，和Conn相关联，并且只能应用于一个goroutine中，不能应用于多个goroutine。

type Stmt interface {
    Close() error
    NumInput() int
    Exec(args []Value) (Result, error)
    Query(args []Value) (Rows, error)
}

Close函数关闭当前的连接状态，可是若是当前正在执行query，query仍是有效返回rows数据。

NumInput函数返回当前预留参数的个数，当返回>=0时数据库驱动就会智能检查调用者的参数。当数据库驱动包不知道预留参数的时候，返回-1。

Exec函数执行Prepare准备好的sql，传入参数执行update/insert等操做，返回Result数据

Query函数执行Prepare准备好的sql，传入须要的参数执行select操做，返回Rows结果集。

driver.Tx

事务处理通常就两个过程，递交或者回滚。数据库驱动里面也只须要实现这两个函数就能够

type Tx interface {
    Commit() error
    Rollback() error
}

这两个函数一个用来递交一个事务，一个用来回滚事务。

driver.Execer

这是一个Conn可选择实现的接口

type Execer interface {
    Exec(query string, args []Value) (Result, error)
}

若是这个接口没有定义，那么在调用DB.Exec,就会首先调用Prepare返回Stmt，而后执行Stmt的Exec，而后关闭Stmt。

driver.Result

这个是执行Update/Insert等操做返回的结果接口定义

type Result interface {
    LastInsertId() (int64, error)
    RowsAffected() (int64, error)
}

LastInsertId函数返回由数据库执行插入操做获得的自增ID号。

RowsAffected函数返回query操做影响的数据条目数。

driver.Rows

Rows是执行查询返回的结果集接口定义

type Rows interface {
    Columns() []string
    Close() error
    Next(dest []Value) error
}

Columns函数返回查询数据库表的字段信息，这个返回的slice和sql查询的字段一一对应，而不是返回整个表的全部字段。

Close函数用来关闭Rows迭代器。

Next函数用来返回下一条数据，把数据赋值给dest。dest里面的元素必须是driver.Value的值除了string，返回的数据里面全部的string都必需要转换成[]byte。若是最后没数据了，Next函数最后返回io.EOF。

driver.RowsAffected

RowsAffected其实就是一个int64的别名，可是他实现了Result接口，用来底层实现Result的表示方式

type RowsAffected int64
func (RowsAffected) LastInsertId() (int64, error)
func (v RowsAffected) RowsAffected() (int64, error)

driver.Value

Value其实就是一个空接口，他能够容纳任何的数据

type Value interface{}

drive的Value是驱动必须可以操做的Value，Value要么是nil，要么是下面的任意一种

  • int64
  • float64
  • bool
  • []byte
  • string [*]除了Rows.Next返回的不能是string.
  • time.Time

driver.ValueConverter

ValueConverter接口定义了如何把一个普通的值转化成driver.Value的接口

type ValueConverter interface {
    ConvertValue(v interface{}) (Value, error)
}

在开发的数据库驱动包里面实现这个接口的函数在不少地方会使用到，这个ValueConverter有不少好处：

  • 转化driver.value到数据库表相应的字段，例如int64的数据如何转化成数据库表uint16字段
  • 把数据库查询结果转化成driver.Value值
  • 在scan函数里面如何把driver.Value值转化成用户定义的值

driver.Valuer

Valuer接口定义了返回一个driver.Value的方式

type Valuer interface {
    Value() (Value, error)
}

不少类型都实现了这个Value方法，用来自身与driver.Value的转化。

database/sql

database/sql在database/sql/driver提供的接口基础上定义了一些更高阶的方法，用以简化数据库操做,同时内部还建议性地实现一个conn pool。

type DB struct {
    driver   driver.Driver
    dsn      string
    mu       sync.Mutex // protects freeConn and closed
    freeConn []driver.Conn
    closed   bool
}

咱们能够看到Open函数返回的是DB对象，里面有一个freeConn，它就是那个简易的链接池。它的实现至关简单或者说简陋，就是当执行Db.prepare的时候会defer db.putConn(ci, err),也就是把这个链接放入链接池，每次调用conn的时候会先判断freeConn的长度是否大于0，大于0说明有能够复用的conn，直接拿出来用就是了，若是不大于0，则建立一个conn,而后再返回之。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程