SORM

简介✨✨✨✨✨✨

​ sorm是一款基于go数据库操作包的orm框架，此项目并非完全的orm框架项目。而更像是一个开发日记，记录每次框架更新迭代的过程，版本号以v开发，例如 v0,v1,v2。

使用日记方式进行框架开发，旨在 😁

1. 加强对数据库系统了解，go语言与数据库交互
2. 向大家记录开发框架全过程，供大家使用
3. 为大家提供pr机会，本人目前的技术水准应该还有待提高，欢迎大家指出🤠
4. 体验处理issue，与pr
5. 在实际的框架开发中，增强自己对go语言的理解

当前支持功能

1. 数据库的连接

2. SQL语句的执行

3. 结构体解析为schema

4. 根据结构体创建数据表

5. 表的删除与是否存在检查

6. CRUD语句的生成与实现

7. 关键词之间的链式调用

8. 钩子的实现

9. 事务实现

版本功能更新记录🚧🚧

v1: 2022.12.25 🥽

1. ORM中logger开发，实现logger分级以及彩色打印
2. session会话实现，sql语句的生成与执行，单条记录查询，多条记录查询
3. 数据库连接

v2: 2022.12.26 🐱‍🏍

1. 不同类型数据库的适配
2. mysql数据类型与go数据类型映射
3. 数据库表模式的定义
4. 数据库表相关操作，创建，删除，是否存在

v3: 2022.12.29 🍿

1.不同关键词字句的生成

2.CURD对应SQL语句的生成与执行

3.关键词之间实现链式调用

v4: 2023.01.01🙆‍♂️

1.钩子的实现

2.事务调用

功能实例

1.根据结构体创建数据表

package main
import (
"fmt"
_ "github.com/go-sql-driver/mysql""sorm"
)
typeUserstruct {
Namestring`sorm:"PRIMARY KEY"`Ageint
}
funcmain() {
dsn:="root:root@tcp(127.0.0.0:3306)/sorm"engine, _:=sorm.NewEngine("mysql", dsn)
deferengine.Close()
s:=engine.NewSession()
err:=s.Model(&User{}).CreateTable()
iferr!=nil {
panic(err)
}
fmt.Println(s.RefTable().Name, "创建成功")
fmt.Printf("字段: %s", s.RefTable().FieldNames)
}

2.向表中插入数据INSERT

package main
import (
"fmt"
_ "github.com/go-sql-driver/mysql""sorm"
)
typeUserstruct {
Namestring`sorm:"PRIMARY KEY"`Ageint
}
funcmain() {
dsn:="root:root@tcp(127.0.0.0:3306)/sorm"engine, _:=sorm.NewEngine("mysql", dsn)
deferengine.Close()
s:=engine.NewSession().Model(&User{})
user1:=User{
Name: "张三",
Age: 18,
}
user2:=User{
Name: "李四",
Age: 19,
}
user3:=User{
Name: "王五",
Age: 18,
}
result, err:=s.Insert(user1, user2, user3)
iferr!=nil {
panic(err)
}
fmt.Println("插入数据条数:", result)
}

3.条件搜索FIND

package main
import (
"fmt"
_ "github.com/go-sql-driver/mysql""sorm"
)
typeUserstruct {
Namestring`sorm:"PRIMARY KEY"`Ageint
}
funcmain() {
dsn:="root:root@tcp(127.0.0.0:3306)/sorm"engine, _:=sorm.NewEngine("mysql", dsn)
deferengine.Close()
varusers []Usersession:=engine.NewSession().Model(&User{})
fmt.Println("-----where限制")
session.Where("Age = ?", "18").Find(&users)
for_, user:=rangeusers {
fmt.Printf("%v\n", user)
}
users= []User{}
fmt.Println("-----order限制")
session.Where("Age = ?", "18").Order("Name desc").Find(&users)
for_, user:=rangeusers {
fmt.Printf("%v\n", user)
}
users= []User{}
fmt.Println("-----limit限制")
session.Where("Age = ?", "18").Order("Name desc").Limit(1).Find(&users)
for_, user:=rangeusers {
fmt.Printf("%v\n", user)
}
users= []User{}
fmt.Println("-----offset限制")
session.Where("Age = ?", "18").Order("Name desc").Limit(1).Offset(1).Find(&users)
for_, user:=rangeusers {
fmt.Printf("%v\n", user)
}
}

4.INSERT语句

funcTestInsertSQLBuild(t*testing.T) {
user1:=User{
Name: "张三",
Age: 18,
}
user2:=User{
Name: "李四",
Age: 19,
}
session:=Engine.NewSession().Model(&User{})
insert, err:=session.Insert(user1, user2)
iferr!=nil {
t.Error(err)
}
fmt.Println(insert)
}

5.FIND语句

funcTestFindSQLBuild(t*testing.T) {
session:=Engine.NewSession().Model(&User{})
varusers []Usererr:=session.Where("Age =?", 18).Order("Age desc").Limit(2).Offset(0).Find(&users)
iferr!=nil {
t.Error(err)
}
for_, user:=rangeusers {
fmt.Printf("%v\n", user)
}
}

6.UPDATE语句

funcTestUpdateSQLBuild(t*testing.T) {
session:=Engine.NewSession().Model(&User{})
result, err:=session.Where("Age =?", 20).Update("Name", "ccccc")
iferr!=nil {
t.Error(err)
}
fmt.Println(result)
}

7.DELETE语句

funcTestDeleteSQLBuild(t*testing.T) {
session:=Engine.NewSession().Model(&User{})
result, err:=session.Where("Age = ?", 20).Delete()
iferr!=nil {
t.Error(err)
}
fmt.Println(result)
}

8.钩子的使用

package test
import (
"fmt""sorm/log""sorm/session""testing"
)
typeTeacherstruct {
Namestring`sorm:"PRIMARY KEY"`Ageint
}
func (teacher*Teacher) BeforeInsert(s*session.Session) error {
log.Info("BEFORE INSERT")
returnnil
}
func (teacher*Teacher) AfterInsert(s*session.Session) error {
log.Info("AFTER INSERT")
returnnil
}
funcTestInsertHooks(t*testing.T) {
s:=Engine.NewSession().Model(&Teacher{})
err:=s.DropTable()
iferr!=nil {
t.Error(err)
}
err=s.CreateTable()
iferr!=nil {
t.Error(err)
}
result, err:=s.Insert(&Teacher{
Name: "张三",
Age: 10,
}, &Teacher{
Name: "李四",
Age: 20,
})
iferr!=nil {
t.Error(err)
}
fmt.Println(result)
}

​ Teacher结构体绑定的钩子很简单，就是打印两条语句，如果想干点其它操作的话可以通过传入的session来完成

9.事务使用

import (
"fmt"
_ "github.com/go-sql-driver/mysql""sorm""sorm/session"
)
typeUserstruct {
Namestring`sorm:"PRIMARY KEY"`Ageint
}
funcmain() {
dsn:="root:root@tcp(127.0.0.1:3306)/sorm"engine, _:=sorm.NewEngine("mysql", dsn)
deferengine.Close()
user:=User{
Name: "ccc",
Age: 1,
}
s:=engine.NewSession().Model(&User{})
fmt.Println("事务第一次调用")
// 1.第一次插入user_, err:=s.Transaction(func(s*session.Session) (resultinterface{}, errerror) {
_, err=s.Insert(&user)
return
})
fmt.Println("事务第二次调用")
// 2.第二次插入user_, err=s.Transaction(func(s*session.Session) (resultinterface{}, errerror) {
_, err=s.Insert(&user)
return
})
iferr!=nil {
fmt.Println(err)
}
}

开发日记

🚗Go_SORM开发日记(一)—SQL生成

🚓Go_SORM开发日记(二)—结构体解析成为表

🚕Go_SORM开发日记(三)—不同关键词字句的生成

🚌Go_SORM开发日记(四)—钩子和事务实现