xorm介绍
官网：https://xorm.io/
git文档：https://github.com/go-xorm/xormxorm 是一个 Go 语言的 ORM（对象关系映射）库，它提供了一种简单、高效的方式来将 Go 语言中的结构体与数据库表进行映射，并提供了丰富的功能来进行数据库操作。
以下是 xorm 的一些特点和功能：
-
支持多种数据库:
xorm支持多种数据库，包括 MySQL、PostgreSQL、SQLite、Microsoft SQL Server、Oracle 等。 -
灵活的映射规则: 通过标签（tag）或者方法可以自定义结构体字段和数据库表字段之间的映射关系。
-
自动建表:
xorm支持根据结构体自动创建数据库表，也可以根据数据库表自动生成相应的结构体。 -
链式操作:
xorm支持链式操作，可以方便地构建复杂的 SQL 查询。 -
事务支持:
xorm支持事务操作，可以确保多个数据库操作的原子性。 -
缓存支持:
xorm提供了缓存机制，可以提高数据库查询的性能。 -
监听器:
xorm支持事件监听器，可以监听数据库操作的各个阶段，并执行相应的逻辑。 -
SQL 日志:
xorm提供了 SQL 日志功能，可以记录数据库操作的 SQL 语句和执行时间，方便调试和性能优化。 -
适用于 Web 开发:
xorm与 Beego、Gin 等常用的 Go Web 框架集成良好，可以方便地在 Web 应用中使用。 -
社区活跃:
xorm是一个开源项目，拥有活跃的开发者社区，提供了丰富的文档和示例。
使用 xorm 可以帮助开发人员简化数据库操作，并提高开发效率。它提供了许多便利的功能和灵活的配置选项，适用于各种规模的项目。
GO安装xorm
go get xorm.io/xorm
xorm连接数据库
使用xorm.NewEngine(“mysql”, dbStr)连接数据库
package main
import (
"fmt"
_ "github.com/go-sql-driver/mysql"
"time"
"xorm.io/xorm"
)
// 准备链接参数信息
var (
userName string = "root"
passWord string = "12345678"
ipAddress string = "127.0.0.1"
port string = "3306"
dbName string = "xorm_test"
charset string = "utf8mb4"
)
func main() {
dbStr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s", userName,
passWord,
ipAddress,
port,
dbName,
charset)
engine, err := xorm.NewEngine("mysql", dbStr)
if err != nil {
fmt.Println(err)
}
}
xorm同步结构体致数据表
通过engine.Sync将结构体生成表，执行后会在xorm_test中生成一张User表
func main() {
dbStr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=%s", userName,
passWord,
ipAddress,
port,
dbName,
charset)
engine, err := xorm.NewEngine("mysql", dbStr)
if err != nil {
fmt.Println(err)
}
type User struct {
Id int64
Name string
Salt string
Age int
Passwd string `xorm:"varchar(200)"`
Created time.Time `xorm:"created"`
Updated time.Time `xorm:"updated"`
}
// 数据同步，将结构体同步至数据库
err1 := engine.Sync(new(User))
if err1 != nil {
fmt.Println(err1)
}
}
exec
exec函数可以搭配所有sql语句来执行相应操作。
//exec 函数+sql语句 ? 为占位符
engine.Exec("update user set age = ? where id = ?", 10, 1003)
插入数据
通过Insert来向数据库中单个或批量添加数据。文章来源：https://www.toymoban.com/news/detail-833538.html
affected, err := engine.Insert(&user)
// INSERT INTO struct () values ()
affected, err := engine.Insert(&user1, &user2)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values ()
affected, err := engine.Insert(&users)
// INSERT INTO struct () values (),(),()
affected, err := engine.Insert(&user1, &users)
// INSERT INTO struct1 () values ()
// INSERT INTO struct2 () values (),(),()
//数据插入
user1 := User{Id: 1000, Name: "xiaohong", Age: 18, Passwd: "123456"}
user2 := User{Id: 1001, Name: "xiaoming", Age: 18, Passwd: "123456"}
n, _ := engine.Insert(&user1, &user2)
fmt.Println(n)
if n >= 1 {
fmt.Println("插入成功")
}
//批量插入 切片
var users []User
users = append(users, User{Id: 1002, Name: "xiaolan", Age: 18, Passwd: "123456"})
users = append(users, User{Id: 1003, Name: "xiaohei", Age: 18, Passwd: "123456"})
n1, _ := engine.Insert(&users)
fmt.Println(n1)
if n1 >= 1 {
fmt.Println("插入成功")
}
更新与删除数据
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("id", 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 = ?
affected, err := engine.Where(...).Delete(&user)
// DELETE FROM user Where ...
affected, err := engine.ID(2).Delete(&user)
// DELETE FROM user Where id = ?
upUser := User{Name: "lyh11"}
upn, _ := engine.ID(1000).Update(upUser)
fmt.Println(upn)
if upn >= 1 {
fmt.Println("更新成功")
}
deln, _ := engine.ID(1002).Delete(&User{})
fmt.Println(deln)
if deln >= 1 {
fmt.Println("删除成功")
}
条件查询与遍历输出
//Query 字节切片 字符串切片 map切片 直接写sql语句进行查询
res, _ := engine.Query("select * from user")
fmt.Println(res)
res1, _ := engine.QueryString("select * from user")
fmt.Println(res1)
res2, _ := engine.QueryInterface("select * from user")
fmt.Println(res2)
//Get 没条件，查询到数据库里的第一条数据
user := User{}
engine.Get(&user)
fmt.Println(user)
//指定条件查询 加条件
user1 := User{Name: "xiaohong"}
engine.Where("name=?", user1.Name).Desc("id").Get(&user1)
fmt.Println(user1)
//获取指定的值 将name拿出来单独赋值
var name string
engine.Table(&user).Where("id=1001").Cols("name").Get(&name)
fmt.Println(name)
//查询多条记录
var users []User
engine.Where("passwd=123456").And("age=18").Limit(10, 0).Find(&users)
fmt.Println(1, users)
//count 获取条数
user2 := User{Name: "xiaoming"}
total, _ := engine.Count(&user2)
fmt.Println(total)
//遍历 Iterate rows
user3 := User{Name: "xiaohong"}
engine.Iterate(&user3, func(idx int, bean interface{}) error {
fmt.Println(1, bean)
fmt.Println(2, bean.(*User))
return nil
})
rows, _ := engine.Rows(&user3)
defer rows.Close()
userBean := new(User)
for rows.Next() {
rows.Scan(userBean)
fmt.Println(33, userBean)
}
事务处理
在数据库操作中，事务（Transaction）是指由一系列操作组成的逻辑工作单元，这些操作要么全部成功执行，要么全部回滚（撤销），以确保数据库的一致性和完整性。文章来源地址https://www.toymoban.com/news/detail-833538.html
session := engine.NewSession()
defer session.Close()
session.Begin()
// 通过panic将恐慌抛出，并做回滚处理
defer func() {
err := recover()
fmt.Println(err)
if err != nil {
session.Rollback()
} else {
session.Commit()
}
}()
user4 := User{Id: 1009, Name: "xiaoming1", Passwd: "123456"}
if _, err := session.Insert(&user4); err != nil {
panic(err)
}
user5 := User{Name: "xiaohaung"}
if _, err := session.Where("id=1000").Update(&user5); err != nil {
panic(err)
}
if _, err := session.Where("name='aaa'").Delete(&User{}); err != nil {
panic(err)
}
到了这里，关于GO框架基础 (三)、xorm库的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
