Sorry, your browser cannot access this site
This page requires browser support (enable) JavaScript
Learn more >

小蜗的博客

主页

标签

归档

友链

Go-Xorm

发布于：May 18, 2023

939 words

4 min

Xorm

特性

  • 支持 Struct 和数据库表之间的灵活映射，并支持自动同步
  • 事务支持
  • 同时支持原始SQL语句和ORM操作的混合执行
  • 使用连写来简化调用
  • 支持使用ID, In, Where, Limit, Join, Having, Table, SQL, Cols等函数和结构体等方式作为条件
  • 支持级联加载Struct
  • Schema支持（仅Postgres）
  • 支持缓存
  • 通过 xorm.io/reverse 支持根据数据库自动生成 xorm 结构体
  • 支持记录版本（即乐观锁）
  • 通过 xorm.io/builder 内置 SQL Builder 支持
  • 上下文缓存支持
  • 支持日志上下文

安装

1
2
go get -u github.com/go-sql-driver/mysql
go get xorm.io/xorm

使用

连接数据库

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//数据库连接基本信息
	var (
		username string = "root"
		password string = "password"
		ip       string = "localhost"
		port     int    = 3306
		dbName   string = "gosql"
		charset  string = "utf8mb4" //数据库字符集
	)
//构建数据库连接信息
dataSourceName :=fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=%s",
                             username, 
                             password, 
                             ip, 
                             port,
                             dbName,
                             charset) //这里对数据库连接信息进行拼接
engine, err := xorm.NewEngine("mysql", dataSourceName)
if err != nil {
		fmt.Printf("连接失败\r\n")
	} else {
		fmt.Printf("连接成功\r\n")
	}

创建与表同步的结构体

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// 与表同步的结构体
type User struct {
	Id      int64
	Name    string
	Age     int
	Salt    string
	Passwd  string    `xorm:"varchar(200)"`
	Created time.Time `xorm:"created"`
	Updated time.Time `xorm:"updated"`
}

err = engine.Sync(new(User))
if err != nil {
	fmt.Println("表结构同步失败！")
} else {
	fmt.Println("表结构同步成功！")
}

增

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//数据插入
user := User{Id: 0001, Name: "小蜗", Age: 20, Salt: " ", Passwd: "root"}
n, _ := engine.Insert(&user)
	if n >= 1 {
		fmt.Println("插入成功")
		}
//切片插入
var users []User
users = append(users, User{Id: 0002, Name: "小蜗", Age: 20, Salt: " ", Passwd: "root"})
users = append(users, User{Id: 0003, Name: "小蜗", Age: 20, Salt: " ", Passwd: "root"})
n, _ := engine.Insert(&users)
	if n >= 1 {
		fmt.Println("切片插入成功")
	}
//update delete
user := User{Name: "小天才"}
n, _ := engine.ID(0001).Update(&user)
	if n >= 1 {
		fmt.Println("update 成功")
	}

删

1
2
3
4
5
user = User{Id: 0002}
n, _ = engine.ID(0002).Delete(&user)
	if n >= 1 {
		fmt.Println("delete 成功")
	}

exec

1
engine.Exec("update user set age = ? where id = ?", 100, 3)

查

1
2
3
4
5
6
7
8
9
10
result, _ := engine.Query("select * from user")
fmt.Println(result)
result1, _ := engine.QueryString("select * from user")
fmt.Println(result1)
result2, _ := engine.QueryInterface("select * from user")
fmt.Println(result2)
//get
user := User{Age: 100}
engine.Get(&user)
fmt.Println(user)

改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
affected, err := engine.ID(1).Update(&user)
// UPDATE user SET ... Where id = ?

affected, err := engine.Update(&user, &User{Name:name})
// UPDATE user SET ... Where name = ?

var ids = []int64{1, 2, 3}
affected, err := engine.In(ids).Update(&user)
// UPDATE user SET ... Where id IN (?, ?, ?)

// force update indicated columns by Cols
affected, err := engine.ID(1).Cols("age").Update(&User{Name:name, Age: 12})
// UPDATE user SET age = ?, updated=? Where id = ?

// force NOT update indicated columns by Omit
affected, err := engine.ID(1).Omit("name").Update(&User{Name:name, Age: 12})
// UPDATE user SET age = ?, updated=? Where id = ?

affected, err := engine.ID(1).AllCols().Update(&user)
// UPDATE user SET name=?,age=?,salt=?,passwd=?,updated=? Where id = ?

事务

什么是事务？

在操作数据库的时候经常需要处理新增，修改，删除等操作，再进行这些操作的时候往往需要用到事物，在新增，修改，删除出错的时候进行回滚操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
session := engine.NewSession()
defer session.Close()

// add Begin() before any action
if err := session.Begin(); err != nil {
    // if returned then will rollback automatically
    return err
}

user1 := Userinfo{Username: "xiaoxiao", Departname: "dev", Alias: "lunny", Created: time.Now()}
if _, err := session.Insert(&user1); err != nil {
    return err
}

user2 := Userinfo{Username: "yyy"}
if _, err := session.Where("id = ?", 2).Update(&user2); err != nil {
    return err
}

if _, err := session.Exec("delete from userinfo where username = ?", user2.Username); err != nil {
    return err
}

// add Commit() after all actions
return session.Commit()

更新于：May 18, 2023

-go

评论