使用Go语言ORM库worm访问PostgreSQL数据库

worm是一款方便易用的Go语言ORM库，worm具有使用简单，运行性能高，功能强大的特点。本文介绍如何使用worm来访问postgres数据库。

创建实体类

CREATE TABLE users(
	id SERIAL PRIMARY KEY,
	name varchar(255) NULL,
	age int NULL,
	passwd varchar](200) NULL,
	created datetime NULL
);

数据库表user对应的实体类的定义如下：

type User struct {
	Id          int64   	`db:"id;autoid"`
	Name        string  	`db:"name"`
	Age         int64   	`db:"age"`
	Passwd      string  	`db:"passwd"`
	Created     time.Time	`db:"created;n_update"`
}
func (ent *User) TableName() string {
	return "users"
}

worm使用名称为"db"的Tag映射数据库字段，"db"后面是字段的名称，autoid用于说明该字段是自增ID，n_update用于说明该字段不可用于update语句中。

创建DbEngine

本文中的例子使用的都是postgres数据库。若要创建一个postgres数据库的DbEngine，您可调用worm.NewPostgres()函数或者调用worm.InitPostgres()函数。

package main
import (
	"database/sql"
	"log"
	_ "github.com/lib/pq"
	"github.com/haming123/wego/worm"
)
func main() {
	cnnstr := "host=127.0.0.1 port=5432 user=user_name password=pwd_str dbname=demo sslmode=disable"
	dbcnn, err := sql.Open("postgres", cnnstr)
	if err != nil {
		log.Println(err)
		return
	}
	err = dbcnn.Ping()
	if err != nil {
		log.Println(err)
		return
	}
	err = worm.InitPostgres(dbcnn)
	if err != nil {
		log.Println(err)
		return
	}
}

插入记录

user := User{Name:"name1", Age: 21, Created: time.Now()}
id, err := worm.Model(&user).Insert()
//insert into user set name=?,age=?,passwd=?,created=?

更新数据

//通过ID更新数据
user := User{Name:"name2", Age: 22}
affected, err := worm.Model(&user).ID(1).Update()
//update user set name=?,age=?,passwd=? where id=?

为了防止误操作，更新数据时必须指定查询条件，若没有指定查询条件worm不会执行该操作。

删除数据

//通过ID删除数据
affected, err := worm.Model(&User{}).ID(1).Delete()
//delete from user where id=?

为了防止误操作，删除数据时必须指定查询条件，若没有指定查询条件worm不会执行该操作。

查询单条记录

//通过ID查询数据
user := User{}
_, err := worm.Model(&user).ID(1).Get()
//select id,name,age,passwd,created from user where id=? limit 1

查询多条记录

//查询全部数据
users := []User{}
err := worm.Model(&User{}).Find(&users)
//select id,name,age,passwd,created from user

//find with limit
users = []User{}
err = worm.Model(&User{}).Limit(5).Offset(1).Find(&users)
// select top 5 id,name,age,passwd,created from users

//使用order查询数据
users = []User{}
err = worm.Model(&User{}).OrderBy("name asc").Find(&users)
//select id,name,age,passwd,created from users order by name asc

查询指定的字段

worm允许通过Select方法选择特定的字段, 或者使用Omit方法排除特定字段

//查询指定的字段
user := User{}
_, err := worm.Model(&user).Select("id", "name", "age").ID(1).Get()
// select id,name,age from users where id=1 limit 1

user = User{}
_, err = worm.Model(&user).Omit("passwd").ID(1).Get()
//select id,name,age,created from users where id=1 limit 1

条件查询

worm支持链式API，可使用Where, And, Or, ID, In等函数构造查询条件。

users := []User{}
err := worm.Model(&User{}).Where("age>?", 0).Find(&users)
//select id,name,age,passwd,created from user where age>?

//and
users = []User{}
err := worm.Model(&User{}).Where("age>?", 0).And("id<?", 10).Find(&users)
//select id,name,age,passwd,created from user where age>? and id<?

//like
users = []User{}
err := worm.Model(&User{}).Where("name like ?", "%name%").Find(&users)
//select id,name,age,passwd,created from user where name like ?

//in
users = []User{}
err := worm.Model(&User{}).Where("age>?", 0).AndIn("id", 5,6).Find(&users)
//select id,name,age,passwd,created from user where age>? and id in (?,?)

worm占位符统一使用?，worm会根据数据库类型,自动替换占位符，例如postgresql数据库把?替换成$1,$2…

获取记录条数

num, err := Model(&User{}).Where("id>?", 0).Count()
//select count(1) from user where id>?

num, err := Model(&User{}).Where("id>?", 0).Count("name")
//select count(name) from user where id>?

检测记录是否存在

has, err := worm.Model(&User{}).Where("id=?", 1).Exist()
//select id,name,age,passwd,created from user where id=? limit 1

Update或Insert数据

var user = User{Name:"name2", Age: 22}
affected,insertId,err := worm.Model(&user).UpdateOrInsert(1)
//根据id判断是Update还是Insert， 若id>0，则调用Update，否则调用Insert
//insert into user set name=?,age=?,passwd=?,created=?
//update user set name=?,age=?,passwd=? where id=?

批量新增

users := []User{User{DB_name:"batch1", Age: 33}, User{DB_name:"batch2", Age: 33} }
res, err := Model(&User{}).BatchInsert(&users)
//insert into user set name=?,age=?,created=?
//TX: time=141.074ms affected=2; prepare

使用原生SQL

• 使用原生SQL执行数据库操作

//插入记录
res, err :=  worm.SQL("insert into users(name, age) values(?,?)", "name1", 1).Exec()
//更新记录
res, err =  worm.SQL("update user set name=? where id=?", "name2", id).Exec()
//删除记录
res, err = worm.SQL("delete from user where id=?", id).Exec()

若需要返回自增ID，则需要按照下面的方式插入记录：

ret, err :=  worm.SQL("insert into users(name, age) values(?,?) RETURNING id", "name1", 1).GetInt()
log.Println(ret.Int64)

• 使用原生SQL查询数据库

//查询单条记录
var name string; var age int64
has, err = worm.SQL("select name,age from user where id=?", 6).Get(&name, &age)

//查询单条记录到model对象
var ent User
has, err := worm.SQL("select * from user where id=?", 6).GetModel(&ent)

//查询多条记录到model数组
var users []User
err := worm.SQL( "select * from user where id>?", 5).FindModel(&users)

使用SQLBuilder

• 使用SQLBuilder执行数据库操作

//插入记录
id, err := worm.Table("user").Value("name", "name1").Value("age", 21).Insert()
//更新记录
affected, err := worm.Table("user").Value("name", "name2").Where("id=?", id).Update()
//删除记录
affected, err = worm.Table("user").Where("id=?", id).Delete()

若需要返回自增ID，则需要按照下面的方式插入记录：

id, _:= worm.Table("users").Value("name", "name1").Value("age", 21).ReturnIng("id").Insert()
log.Println(id)

• 使用SQLBuilder查询数据库

//查询单条记录
var name string; var age int64
has, err = worm.Table("user").Select("name", "age").Where("id=?", 6).Get(&name, &age)

//查询单条记录到model对象
var ent User
has, err := worm.Table("user").Select("*").Where("id=?", 6).GetModel(&ent)

//查询多条记录
var users []User
err :=  worm.Table("user").Select("*").Where("id>?", 0).FindModel(&users)

关联查询

定义一个book表以及相应的实体类：

CREATE TABLE book (
  name varchar(36) DEFAULT NULL,
  author bigint DEFAULT NULL,
  price numeric(10,6) DEFAULT 0.0 NULL
);

type Book struct {
	Author  	int64       `db:"author"`
	Name        string  	`db:"name"`
	Price       float32     `db:"price"`
}
func (ent *Book) TableName() string {
	return "book"
}

在book表中，通过author字段与user表的id字段相关联。若要查询一个用户购买的书，在worm中可以通过Join来查询：

type UserBook struct {
    User	User
    Book	Book
}
var datas []UserBook
md := worm.Model(&User{}).Select("id","name","age").TableAlias("u")
md.Join(&Book{}, "b", "b.author=u.id", "name")
err := md.Where("u.id>?", 0).Find(&datas)
//select u.id as u_id,u.name as u_name,u.age as u_age,b.name as b_name from user u join book b on b.author=u.id where u.id>0

除了Join，您还可以使用LeftJoin以及RightJoin进行左连接、右连接查询。

事务处理

当使用事务处理时，需要创建 Session对象，并开启数据库事务。在进行事务处理时，在事务中可以混用Model模式、原生SQL模式以及SQL builder模式来操作数据库：

tx := worm.NewSession()
tx.TxBegin()
user := User{Name:"name1", Age: 21, Created: time.Now()}
id, err := tx.Model(&user).Insert()
if err != nil{
    tx.TxRollback()
    return
}
_, err = tx.Table("user").Value("age", 20).Value("name", "zhangsan").Where("id=?", id).Update()
if err != nil{
    tx.TxRollback()
    return
}
_, err = tx.SQL("delete from user where id=?", id).Exec()
if err != nil{
    tx.TxRollback()
    return
}
tx.TxCommit()

使用SQL语句预编译

worm支持SQL语句的预编译，使用SQL语句预编译可以提升数据库访问的效率。在worm中可以通过三种方式开启SQL语句预编译：全局开启、会话中开启、语句中开启。

//全局开启，所有操作都会创建并缓存预编译
worm.UsePrepare(true)

//会话中开启, 会话中的sql语句会创建并缓存预编译
dbs := worm.NewSession()
dbs.UsePrepare(true)

//语句中使用UsePrepare
user := User{}
_, err := Model(&user).UsePrepare(true).Where("id=?", 1).Get()