创建实体类

使用worm.Model前必须先定义实体类，worm.Model通过实体类来映射数据库字段，并进行数据库操作。

CREATE TABLE `users` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT,
  `name` varchar(30) DEFAULT NULL,
  `age` int(11) DEFAULT NULL,
  `passwd` varchar(32) DEFAULT NULL,
  `created` datetime DEFAULT NULL,
  `updated` datetime DEFAULT NULL,
  PRIMARY KEY (`id`)
);

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

type User struct {
	Id          int64   	`db:"id;autoincr"`
	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.Model执行数据库操作

func demoModelCUD() {
	//插入记录
	var user = User{Name:"name1", Age: 21, Created: time.Now()}
	id, err := worm.Model(&user).Insert()
	if err != nil{
		log.Println(err)
		return
	}
	//insert into users set name=?,age=?,passwd=?,created=?

	//更新记录
	user.Name = "name2"
	user.Age = 22
	_, err = worm.Model(&user).ID(id).Update()
	if err != nil{
		log.Println(err)
		return
	}
	//update users set name=?,age=?,passwd=? where id=?

	//删除记录
	_, err = worm.Model(&User{}).ID(id).Delete()
	if err != nil{
		log.Println(err)
		return
	}
	//delete from users where id=?
}

说明：

• worm占位符统一使用?，worm会根据数据库类型,自动替换占位符，例如postgresql数据库把?替换成$1,$2...
• 为了防止误操作，更新数据时必须指定查询条件，若没有指定查询条件worm不会执行该操作。
• 为了防止误操作，删除数据时必须指定查询条件，若没有指定查询条件worm不会执行该操作。

基于编辑状态来更新数据库

使用worm.Model().Update()方法来更新数据库时，则worm缺省会更新实体类对应的全部字段。若只希望更新指定的字段，可以使用若Select方法指定需要更新的字段：

func demoModelUpdate() {
	var user = User{Name:"name1", Age: 21, Created: time.Now()}
	_, err := worm.Model(&user).Select("name", "age").ID(1).Update()
	if err != nil{
		log.Println(err)
		return
	}
}
//update users set name=?,age=? where id=?

Select方法虽然能够做到按需更新，但是若库表的字段比较多，这种方法使用起来则比较麻烦，也容易引起错误（更新了不该更新的字段）。worm提供了一种基于编辑状态来更新数据库的方法：

• 首先创建实体类
• 接着Model对象，并将实体类指针传递给Model
• 然后使用SetValue方法逐个给字段赋值
• 最后调用Update()方法更新数据库

func demoModelUpdateX() {
	var user = User{}
	md := worm.Model(&user)
	md.SetValue(&user.Name, "name2")
	md.SetValue(&user.Age, 22)
	_, err := md.ID(1).Update()
	if err != nil{
		log.Println(err)
		return
	}
}
//update users set name=?,age=? where id=?

查询单条记录

worm通过调用Get方法来查询一条数据库记录，在使用Get方法时可以通过Where方法来指定SQL语句的查询条件。

func demoGet() {
	var ent User
	_, err := worm.Model(&ent).Where("name=?", "name_89").Get()
	if err != nil{
		log.Println(err)
		return
	}
	log.Println(ent)
}
//select id,name,age,passwd,created from users where name=? limit 1

若查询时使用的字段为ID，则可以采用更为简洁的方式来调用Get方法：

func demoGetByID() {
	var ent User
	_, err := worm.Model(&ent).ID(1).Get()
	if err != nil{
		log.Println(err)
		return
	}
	log.Println(ent)
}
//select id,name,age,passwd,created from users where id=? limit 1

查询指定的字段

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

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

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

查询多条记录

func demoFindUser() {
	//find all
	users := []User{}
	worm.Model(&User{}).Find(&users)

	//limit
	users = []User{}
	worm.Model(&User{}).Limit(5).Offset(1).Find(&users)

	//OrderBy
	users = []User{}
	worm.Model(&User{}).OrderBy("name asc").Find(&users)
}

条件查询

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

func demoFindUser() {
	//and
	users = []User{}
	worm.Model(&User{}).Where("age>?", 0).And("id<?", 10).Find(&users)

	//in
	users = []User{}
	worm.Model(&User{}).Where("age>?", 0).AndIn("id", 1,2).Find(&users)

	//like
	users = []User{}
	worm.Model(&User{}).Where("name like ?", "%name%").Find(&users)
}

迭代

func demoModelRows() {
	rows, err := worm.Model(&User{}).Where("id>?", 0).Rows()
	if err != nil{
		log.Println(err)
		return
	}
	defer rows.Close()

	for rows.Next(){
		var user User
		err = rows.Scan(&user)
		if err != nil{
			log.Println(err)
		}
		log.Println(user)
	}
}

获取记录条数

func demoModelCount() {
	num, err := worm.Model(&User{}).Where("id>?", 0).Count()
	if err != nil {
		log.Println(err)
		return
	}
	log.Println(num)
	num, err = worm.Model(&User{}).Where("id>?", 0).Count("name")
	if err != nil {
		log.Println(err)
		return
	}
	log.Println(num)
}

检测记录是否存在

func demoModelExist() {
	has, err := worm.Model(&User{}).Where("id=?", 1).Exist()
	if err != nil{
		log.Println(err)
		return
	}
	log.Println(has)
}

Update或Insert数据

UpdateOrInsert函数根据id判断是Update还是Insert， 若id>0，则调用Update，否则调用Insert。

func demoUpdateOrInsert() {
	var user = User{Name:"name2", Age: 22, Created: time.Now()}
	_, id, err := worm.Model(&user).UpdateOrInsert(1)
	if err != nil{
		log.Println(err)
		return
	}
	log.Println(id)
}