DROP TABLE IF EXISTS "users";
CREATE TABLE "users" (
     "uid" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
     "name" TEXT NOT NULL,
     "age" integer NOT NULL
);

INSERT INTO "users" VALUES (1, 'gorose', 18);
INSERT INTO "users" VALUES (2, 'goroom', 18);
INSERT INTO "users" VALUES (3, 'fizzday', 18);
``` **github.com/gohouse/gorose/v2**  

*github.com/mattn/go-sqlite3)*  

type Users struct { Uid int64 gorose:"uid" Name string gorose:"name" Age int64 gorose:"age" Xxx interface{} gorose:"-" // 这个字段在orm中会忽略 }

func (u *Users) TableName() string { return "users" }

var err error var engin *gorose.Engin

func init() { // 全局初始化数据库,并复用 // 这里的engin需要全局保存,可以用全局变量,也可以用单例 // 配置&gorose.Config{}是单一数据库配置 // 如果配置读写分离集群,则使用&gorose.ConfigCluster{} engin, err = gorose.Open(&gorose.Config{Driver: "sqlite3", Dsn: "./db.sqlite"}) } func DB() gorose.IOrm { return engin.NewOrm() } func main() { // 这里定义一个变量db, 是为了复用db对象, 可以在最后使用 db.LastSql() 获取最后执行的sql // 如果不复用 db, 而是直接使用 DB(), 则会新建一个orm对象, 每一次都是全新的对象 // 所以复用 db, 一定要在当前会话周期内 db := DB()

// 查询一条
var u Users
// 查询数据并绑定到 user{} 上
err = db.Table(&u).Fields("uid,name,age").Where("age",">",0).OrderBy("uid desc").Select()
if err!=nil {
    fmt.Println(err)
}
fmt.Println(u, u.Name)
fmt.Println(db.LastSql())

// 查询多条
// 查询数据并绑定到 []Users 上, 这里复用了 db 及上下文参数
// 如果不想复用,则可以使用DB()就会开启全新会话,或者使用db.Reset()
// db.Reset()只会清除上边查询的参数干扰,不会更换链接,DB()则会更换链接
var u2 []Users
err = db.Limit(10).Offset(1).Select()
fmt.Println(u2)

// 统计数据
var count int64
// 这里reset清除上边查询的参数干扰, 可以统计所有数据, 如果不清楚, 则条件为上边查询的条件
// 同时, 可以新调用 DB(), 也不会产生干扰
count,err = db.Reset().Count()
// 或
count, err = DB().Table(&u).Count()
fmt.Println(count, err)

}

**高级用法**

- Chunk 数据分片 大量数据批量处理 (累积处理)   

   `当需要操作大量数据的时候, 一次性取出再操作, 不太合理, 就可以使用chunk方法`  
   `chunk的第一个参数是指定一次操作的数据量, 根据业务量, 取100条或者1000条都可以`  
   `chunk的第二个参数是一个回调方法, 用于书写正常的数据处理逻辑`  
   `目的是做到, 无感知处理大量数据`  
   `实现原理是, 每一次操作, 自动记录当前的操作位置, 下一次重复取数据的时候, 从当前位置开始取`  

   ```go
   User := db.Table("users")
   User.Fields("id, name").Where("id",">",2).Chunk(2, func(data []gorose.Data) error {
      // for _,item := range data {
      //     fmt.Println(item)
      // }
      fmt.Println(data)

      // 这里不要忘记返回错误或nil
      return nil
   })

   // 打印结果:
   // map[id:3 name:gorose]
   // map[id:4 name:fizzday]
   // map[id:5 name:fizz3]
   // map[id:6 name:gohouse]
   [map[id:3 name:gorose] map[name:fizzday id:4]]
   [map[id:5 name:fizz3] map[id:6 name:gohouse]]

• Loop 数据分片 大量数据批量处理 (从头处理)

  类似 chunk 方法, 实现原理是, 每一次操作, 都是从头开始取数据
原因: 当我们更改数据时, 更改的结果可能作为where条件会影响我们取数据的结果,所以, 可以使用Loop

  User := db.Table("users")
  User.Fields("id, name").Where("id",">",2).Loop(2, func(data []gorose.Data) error {
      // for _,item := range data {
      //     fmt.Println(item)
      // }
      // 这里执行update / delete  等操作
  
      // 这里不要忘记返回错误或nil
      return nil
  })

• 嵌套where

  // SELECT  * FROM users
  //     WHERE  id > 1
  //         and ( name = 'fizz'
  //             or ( name = 'fizz2'
  //                 and ( name = 'fizz3' or website like 'fizzday%')
  //                 )
  //             )
  //     and job = 'it' LIMIT 1
  User := db.Table("users")
  User.Where("id", ">", 1).Where(func() {
          User.Where("name", "fizz").OrWhere(func() {
              User.Where("name", "fizz2").Where(func() {
                  User.Where("name", "fizz3").OrWhere("website", "like", "fizzday%")
              })
          })
      }).Where("job", "it").First()

升级日志

v2.1.x:

• join表自动加前缀,不需要再手动加前缠
• 原生sql的query()方法,增加返回结果集[]map[string]interface{}

v2.0.0: 船新版本,船新架构

升级指南

从2.0.x升级到2.1.x

xxx.Join("pre_tablename")更改为xxx.Join("tablename"),这里不需要手动指定表前缠
err:=DB().Bind().Query(),更改为多返回res,err:=DB().Query(),同时保留了Bind()用法

从1.x升级到2.x, 全新安装

赞助渠道

微信	支付宝	paypal: click

• 捐赠列表

total | avator 100 иен |