xorm持久化框架使用

前言

xorm是go中一个强大的持久化框架,通过使用xorm库，可以方便操作数据库，而且其支持多种数据库操作，让go操作数据库变得更加简单和易维护

xorm使用

xrom依赖安装

使用以下命令安装xorm依赖

go get xorm.io/xorm

安装对用数据库依赖

mysql

go get github.com/go-sql-driver/mysql

Postgres

go get github.com/lib/pq 

tidb

go get github.com/pingcap/tidb

SQLite

go get github.com/mattn/go-sqlite3

MsSQL

go get github.com/denisenkom/go-mssqldb

xorm程序使用

xorm连接数据库

备注:本文使用的是mysql

使用以下代码配置数据库

user:password@/dbname

xorm连接数据库

package main

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


func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    log.Println("=========连接数据库成功")
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

结果为

插入数据

（1）定义一个数据表实体类

type User struct {
    Id       int64 `xorm:"'id' pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

（2）插入数据为

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    var user = User{
       Name:     "aaa",
       Password: "123456",
    }
    count, err2 := engine.Table(&User{}).Insert(&user)
    if err2 != nil {
       log.Println("插入数据异常:", err2)
       return
    }
    log.Println("======插入数据返回值为:", count)
    log.Println("==========插入值为:", user)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

输出值为

数据库数据为

查询数据

根据Id查询

（1）查询刚才那条数据为10的数据

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    var user User
    get, err := engine.Table(&User{}).ID(10).Get(&user)
    if err != nil {
       log.Println("=====查询失败:", err)
       return
    }
    log.Println("查询返回值为:", get)
    log.Println("返回值为:", user)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

结果为

（2）查询不到数据

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    var user User
    get, err := engine.Table(&User{}).ID(11).Get(&user)
    if err != nil {
       log.Println("=====查询失败:", err)
       return
    }
    log.Println("查询返回值为:", get)
    log.Println("返回值为:", user)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

返回值为

where查询

（1）获取单条值

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    var user User
    get, err := engine.Table(&User{}).Where("id=?", 10).Get(&user)
    if err != nil {
       log.Println("=====查询失败:", err)
       return
    }
    log.Println("查询返回值为:", get)
    log.Println("返回值为:", user)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

输出结果为

（2）查询多个值

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    var user []User
    engine.Table(&User{}).Where("name=?", "aaa").Find(&user)
    log.Println("返回值为:", user)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

返回值为

更新数据

（1）根据id更新数据

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    engine.ShowSQL(true)
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    user3 := User{
       Id:       10,
       Name:     "new",
       Password: "aaaa",
    }

    rows, err1 := engine.Table(&User{}).ID(10).Update(&user3)
    if err1 != nil {
       log.Println("更新失败:", err1)
       return
    }
    log.Println("更新行数:", rows)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

（2）根据条件更新

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    engine.ShowSQL(true)
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")
    user3 := User{
       Id:       10,
       Name:     "new",
       Password: "aaaa",
    }

    rows, err1 := engine.Table(&User{}).Where("id = ?", 11).Update(&user3)
    if err1 != nil {
       log.Println("更新失败:", err1)
       return
    }
    log.Println("更新行数:", rows)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

输出结果为

删除数据

（1）根据id删除数据为

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    engine.ShowSQL(true)
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")

    rows, err1 := engine.Table(&User{}).ID(10).Delete(&User{})
    if err1 != nil {
       log.Println("删除失败:", err1)
       return
    }
    log.Println("删除行数:", rows)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

输出结果为

（2）根据条件删除

删除name=aaa的数据

package main

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

type User struct {
    Id       int64 `xorm:"pk autoincr"`
    Name     string
    Password string    `xorm:"varchar(255)"`
    Created  time.Time `xorm:"created"` // 创建的时候自动创建
    Updated  time.Time `xorm:"updated"` // 更新的时候自动更新
}

func main() {
    engine, err := xorm.NewEngine("mysql", "root:123456@tcp(localhost:3306)/test?charset=utf8")
    if err != nil {
       fmt.Println("连接数据库错误:", err)
       return
    }
    engine.ShowSQL(true)
    isExists, err1 := engine.IsTableExist(&User{})
    if err1 != nil {
       log.Println("判断数据表是否存在错误:", err1)
       return
    }
    if !isExists {
       engine.Sync(&User{})
    }
    log.Println("=========连接数据库成功")

    var user = User{
       Name: "aaa",
    }

    rows, err1 := engine.Table(&User{}).Delete(&user)
    if err1 != nil {
       log.Println("删除失败:", err1)
       return
    }
    log.Println("删除行数:", rows)
    defer func(engine *xorm.Engine) {
       err := engine.Close()
       if err != nil {

       }
    }(engine)
}

总结

xorm还提供了很多丰富的方法供开发使用，是一个非常优秀的持久化框架，可以根据自己熟悉程度做技术选型