xorm:golang的orm(只写了一小部分)

其他 2019-08-26 18:38:02 阅读次数: 0

xorm

xorm是一个简单而强大的Go语言ORM库. 通过它可以使数据库操作非常简便。这个库是国人开发的，是基于原版 xorm：https://github.com/go-xorm/xorm 的定制增强版本。安装该orm的话，直接通过go get -u github.com/xormplus/xorm即可

当然orm并不能直接操作数据库，还是要借助第三方驱动的，目前支持的驱动如下

  • Mysql: https://github.com/go-sql-driver/mysql
  • MyMysql: https://github.com/ziutek/mymysql
  • Postgres: https://github.com/lib/pq
  • Tidb: https://github.com/pingcap/tidb
  • SQLite: https://github.com/mattn/go-sqlite3
  • MsSql: https://github.com/denisenkom/go-mssqldb
  • Oracle: https://github.com/mattn/go-oci8 (试验性支持)

创建引擎

引擎使用来执行我们所写的sql语句的

package main

import (
    "fmt"
    _ "github.com/lib/pq" // 引用驱动，python中，是不需要显示引用的，但是golang需要引用执行以下内部的Init函数,我这里是postgresql，其他数据库就换成其他的驱动
    "github.com/xormplus/core"
    "github.com/xormplus/xorm"
)

func main() {
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    // 引擎这里结尾要加上一个sslmode=disable，不然会报出：pq: SSL is not enabled on the server
    if err != nil {
        fmt.Println(err)
    } else {
        //调用engine.Ping可以查看是否建立成功
        _ = engine.Ping()  // [xorm] [info]  2019/08/25 21:14:49.581814 PING DATABASE postgres
    }

    //此外还可以设置日志，通过设置日志，可以显示sql、警告和错误信息等等，默认的显示级别为info
    engine.ShowSQL(true) // 则会在控制台打印出生成的SQL语句
    engine.Logger().SetLevel(core.LOG_DEBUG) //则会在控制台打印info及以上的信息
    /*
    如果希望将信息不仅打印到控制台，而是保存为文件，那么可以通过类似如下的代码实现，NewSimpleLogger(w io.Writer)接收一个io.Writer接口来将数据写入到对应的设施中。
    f, err := os.Create("sql.log")
    if err != nil {
        println(err.Error())
        return
    }
    engine.SetLogger(xorm.NewSimpleLogger(f))
     */

    //此外还可以设置连接池
    /*
    如果需要设置连接池的空闲数大小，可以使用engine.SetMaxIdleConns(n)来实现
    如果需要设置最大打开连接数，则可以使用engine.SetMaxOpenConns(n)来实现。
     */
}

获取表信息

package main

import (
    "fmt"
    _ "github.com/lib/pq" // 引用驱动，python中，是不需要显示引用的，但是golang需要引用执行以下内部的Init函数,我这里是postgresql，其他数据库就换成其他的驱动
    "github.com/xormplus/xorm"
)

func main() {
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    if err != nil {
        fmt.Println(err)
    } else {
        // info是一个切片，存储的数据类型为*core.Table，*core.Table是一个结构体指针，我们来看看都有哪些属性
        /*
        type Table struct {
            Name          string
            Type          reflect.Type
            columnsSeq    []string
            columnsMap    map[string][]*Column
            columns       []*Column
            Indexes       map[string]*Index
            PrimaryKeys   []string
            AutoIncrement string
            Created       map[string]bool
            Updated       string
            Deleted       string
            Version       string
            Cacher        Cacher
            StoreEngine   string
            Charset       string
            Comment       string
        }
         */
        info, err := engine.DBMetas()
        if err != nil {
            fmt.Println(err)
        }else {
            for _, v := range info{
                fmt.Println(fmt.Sprintf("表名：%s", v.Name))
                /*
                表名：alembic_version
                表名：user1
                表名：heroes
                 */
            }
        }
    }
}

此外还可以判断表是否存在，表是否为空，以及删除表

package main

import (
    "fmt"
    _ "github.com/lib/pq" // 引用驱动，python中，是不需要显示引用的，但是golang需要引用执行以下内部的Init函数,我这里是postgresql，其他数据库就换成其他的驱动
    "github.com/xormplus/xorm"
)

func main() {
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    if err != nil {
        fmt.Println(err)
    } else {
        //判断user1是否存在
        flag, _ := engine.IsTableExist("user1")
        fmt.Println(flag) // true

        //判断user1内容是否为空
        flag, _ = engine.IsTableEmpty("user1")
        fmt.Println(flag) // false

        //删除user1,DropTables可以接收多个参数
        _ = engine.DropTables("user1")
        //再来查看user1是否存在
        flag, _ = engine.IsTableExist("user")
        fmt.Println(flag) // false
    }
}

创建表

首先可以原生建表

package main

import (
    "fmt"
    _ "github.com/lib/pq" // 引用驱动，python中，是不需要显示引用的，但是golang需要引用执行以下内部的Init函数,我这里是postgresql，其他数据库就换成其他的驱动
    "github.com/xormplus/xorm"
)

func main() {
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    if err != nil {
        fmt.Println(err)
    } else {
        create_table_sql := `
            create table girls(
            id int primary key,
            name varchar(255) not null,
            age int not null,
            gender varchar(1)
        )
        `
        //调用engine.Exec可以执行原生sql语句
        res, err := engine.Exec(create_table_sql)
        if err != nil {
            fmt.Println(err)
        }else {
            //res是一个sql.Result类型
            /*
            type Result interface {
                LastInsertId() (int64, error)
                RowsAffected() (int64, error)
            }
             */
            //这两行打印的无所谓，只要上面的err为nil即可，我们看看数据库里面有没有表
            fmt.Println(res.LastInsertId()) // 0 LastInsertId is not supported by this driver
            fmt.Println(res.RowsAffected()) // 0 <nil>
        }
    }
}

创建成功了的

orm形式建表

在golang中，使用结构体映射为数据库中的字段

package main

import (
    "fmt"
    _ "github.com/lib/pq" // 引用驱动，python中，是不需要显示引用的，但是golang需要引用执行以下内部的Init函数,我这里是postgresql，其他数据库就换成其他的驱动
    "github.com/xormplus/xorm"
)

func main() {
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    if err != nil {
        fmt.Println(err)
    } else {
        type boy struct {
            // 字段名 类型 tag
            //golang的orm中的约束使用tag来体现,多个约束使用空格分割

            /*
            pk表示主键 autoincr 自增
            如果Field名就叫做Id，并且类型为int64，如果不加tag，会自动被xorm视为主键，并且自增。
            如果想用Id以外、或者非int64类型作为主键，必须要显示的在tag中指定，`xorm:"pk autoincr"`
             */
            Id int `xorm:"pk autoincr"`

            /*
            '姓名'是映射到数据库的字段名，如果不指定则是当前结构体字段(Field)的名称
            建议使用单引号括起来放到最后
             */
            Name string `xorm:"varchar(255) not null '姓名'"`

            /*
                default，默认值
             */
            Age int `xorm:"not null default 16 '年龄'"`

            /*
            default，默认值，如果是varchar则需要加上单引号
             */
            Gender int `xorm:"varchar(1) not null default '女' '性别'"`
        }

        //可以指定schema，对于postgresql来说，很多时候还是要指定schema的
        engine.SetSchema("anime") //设置schema为anime

        //使用engine.Sync(new(boy))，完成映射
        err := engine.Sync(new(boy))
        if err != nil {
            fmt.Println(err)
        }
    }
}

也是创建成功了的

扫描二维码关注公众号，回复： 7102474 查看本文章

插入数据

orm形式插入数据

package main

import (
    "fmt"
    "github.com/xormplus/xorm"
)
import _"github.com/lib/pq"

func main() {
    engine, _ := xorm.NewPostgreSQL("postgres://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    type girl struct {
        Id int `xorm:"pk autoincr"`
        Name string `xorm:"varchar(255) not null"`
        Age int `xorm:"not null"`
        //CreatedAt time.Time `xorm:"created"` 会自动加上当前的创建时间
    }
    engine.SetSchema("anime")
    _ = engine.Sync(new(girl))

    g := &girl{Name:"satori", Age:16}
    //插入数据可以使用Insert方法，对象可以是一个struct对象指针，插入一条数据，或者多个struct指针组成的切片所对应的指针，插入多条数据
    //注意到这里没有传入Id，因为Id在数据库中是自增的。如果给Id赋值了，那么该字段会作为非自增字段插入
    affected, err:= engine.Insert(g) // 返回两个结果，受影响的行数和err
    if err != nil {
        fmt.Println(err)
    } else {
        fmt.Println("受影响的行数", affected)
    }

    //插入多条数据
    rows := []*girl{
        {Name:"koishi", Age:16},
        {Name:"frandlescarlet", Age:400},
        {Name:"mashiro", Age:16},
    }
    affected, err = engine.Insert(&rows) // 对的，这里切片也要传递指针
    if err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println("受影响的行数", affected)
    }
    /*
    受影响的行数 1
    受影响的行数 3
     */
}

原生形式插入数据

package main

import (
    "github.com/xormplus/xorm"
)
import _"github.com/lib/pq"

func main() {
    engine, _ := xorm.NewPostgreSQL("postgres://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")

    // 第一种方式
    sql_1 := "insert into anime.girl(name, age) values('kurisu', 18)"
    _, _ = engine.Exec(sql_1)
    // 第二种方式
    sql_2 := "insert into anime.girl(name, age) values(?, ?)"
    _, _ = engine.Exec(sql_2, "nagisa", 20)

    // 第三种方式
    sql_3 := "insert into anime.girl(name, age) values(?, ?)"
    _, _ = engine.SQL(sql_3, "tomoyo", 18).Execute()
}

查询和统计数据

支持执行SQL与ORM两种方式查询数据

orm方式查询和统计数据

package main

import (
    "fmt"
    "github.com/xormplus/xorm"
)
import _"github.com/lib/pq"

//字段名大写，和数据库的表的字段名保持一致即可
//结构体的名字和表名一致即可，这里可以大写可以小写
type Girl struct {
    Id int64
    Name string
    Age int
}

func main(){
    engine, err := xorm.NewPostgreSQL("postgresql://postgres:zgghyys123@localhost:5432/postgres?sslmode=disable")
    if err != nil {
        fmt.Println(err)
    }
    //指定schema
    engine.SetSchema("anime")

    //创建一个结构体指针
    g1 := new(Girl)

    //使用engine.Get方法，传入相应的指针
    //返回两个参数，第一个参数表示记录是否存在，第二个表示是否有错
    has, err := engine.Get(g1)
    if err!= nil {
        fmt.Println(err)
    }else {
        fmt.Println(has) // true
    }
    //正确执行engine.Get之后，记录会存到g1里面
    //注意Get方法只会获取一条记录，那么默认是符合条件的第一条
    fmt.Println(g1) // &{1 satori 16}


    /*
    Find:Get是查询一条数据，Find查询多条
    那么此时Find里面接收的则是一个切片对应的指针，切片的类型是相应结构体类型
     */
    girl1 := make([]Girl, 0)
    if err := engine.Find(&girl1); err!=nil{
        fmt.Println(err)
    }else{
        //这样就全部获取出来了
        fmt.Println(girl1) // [{1 satori 16} {2 koishi 16} {3 frandlescarlet 400} {4 mashiro 16} {5 kurisu 18} {6 nagisa 20} {7 tomoyo 18}]
    }


    /*
        where:查询
    */
    girl2 := make([]Girl, 0)
    if  err = engine.Where("name = ?", "koishi").Find(&girl2);err!=nil{
        fmt.Println(nil)
    }else{
        fmt.Println(girl2) // [{2 koishi 16}]
    }

    girl3 := make([]Girl, 0)
    if err = engine.Where("name = ? and age = ?", "koishi", 16).Find(&girl3);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl3) // [{2 koishi 16}]
    }

    girl4 := make([]Girl, 0)
    //where语句可以重复嵌套
    if err = engine.Where("name = ?", "koishi").Where("age = ?", 16).Find(&girl4);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl4) // [{2 koishi 16}]
    }


    /*
    And:和where基本相同
     */
    girl5 := make([]Girl, 0)
    if err = engine.Where("name = ?", "mashiro").And("age = ?", 16).Find(&girl5);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl5) // [{4 mashiro 16}]
    }

    /*
    Or:
     */
    girl6 := make([]Girl, 0)
    if err = engine.Where("name = ?", "mashiro").Or("age = ?", 16).Find(&girl6);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl6) // [{1 satori 16} {2 koishi 16} {4 mashiro 16}]
    }

    girl7 := make([]Girl, 0)
    if err = engine.Where("name = ? or age = ?", "mashiro", 16).Find(&girl7);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl7) // [{1 satori 16} {2 koishi 16} {4 mashiro 16}]
    }

    /*
    Asc:正序排序
     */
    girl8 := make([]Girl, 0)
    if err = engine.Asc("name").Find(&girl8);err!=nil{
        fmt.Println(err)
    }else {
        fmt.Println(girl8) // [{3 frandlescarlet 400} {2 koishi 16} {5 kurisu 18} {4 mashiro 16} {6 nagisa 20} {1 satori 16} {7 tomoyo 18}]
    }


    /*
        Desc:正序排序
    */
    girl9 := make([]Girl, 0)
    if err = engine.Desc("name").Find(&girl9);err!=nil{
        fmt.Println(err)
    }else {
        fmt.Println(girl9) // [{7 tomoyo 18} {1 satori 16} {6 nagisa 20} {4 mashiro 16} {5 kurisu 18} {2 koishi 16} {3 frandlescarlet 400}]
    }


    /*
    OrderBy:按照指定的顺序排序,和Asc类似
     */
    girl10 := make([]Girl, 0)
    if err = engine.OrderBy("name").Find(&girl10);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl10) // [{3 frandlescarlet 400} {2 koishi 16} {5 kurisu 18} {4 mashiro 16} {6 nagisa 20} {1 satori 16} {7 tomoyo 18}]
    }


    /*
    Select:选择想要的字段
     */
    girl11 := make([]Girl, 0)
    if err = engine.Select("id,name").Find(&girl11);err!=nil{
        fmt.Println(err)
    }else{
        //只选择id和name，可以看到age全是零值
        fmt.Println(girl11) //[{1 satori 0} {2 koishi 0} {3 frandlescarlet 0} {4 mashiro 0} {5 kurisu 0} {6 nagisa 0} {7 tomoyo 0}]
    }


    /*
    In
     */
    girl12 := make([]Girl, 0)
    if err = engine.In("id", []int{1, 2,5}).Find(&girl12);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl12) // [{1 satori 16} {2 koishi 16} {5 kurisu 18}]
    }


    /*
    Distinct
     */
    girl13 := make([]Girl, 0)
    if err = engine.Distinct("age").Find(&girl13);err!=nil{
        fmt.Println(err)
    }else {
        fmt.Println(girl13) // [{0  16} {0  400} {0  20} {0  18}]
    }


    /*
    Limit:
     */
    girl14 := make([]Girl, 0)
    //Limit(2, 3)：取两条，从第三条开始
    if err = engine.Limit(2, 3).Find(&girl14);err!=nil{
        fmt.Println(err)
    }else{
        fmt.Println(girl14) //[{4 mashiro 16} {5 kurisu 18}]
    }

}

不想写了，可以查看https://www.kancloud.cn/xormplus/xorm/167094

猜你喜欢

转载自www.cnblogs.com/traditional/p/11414089.html
今日推荐
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
“百模大战”必有一战 | 2024中国“百模大战”竞争格局分析
周排行
Family Tree 题解
BZOJ 1093 最大半连通子图 SCC + DP
幂等处理
Spring----学习（2）----XML 配置Bean 自动装配
SQL Server 远程更新目标表数据
HIbernate3.6 环境搭建
特殊符号正则表达式
【Linux】第一章 进程的理解
843. n-皇后问题（dfs+输出各种情况）
空间数据库2
每日归档
更多
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)
2024-04-17(5)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022