GoMybatis

package module
v5.0.3+incompatible Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 3, 2019 License: Apache-2.0 Imports: 15 Imported by: 0

README

Go语言sql数据库orm框架

Go Report Card Build Status GoDoc Coverage Status codecov

Image text

使用教程请仔细阅读文档网站 https://zhuxiujia.github.io/gomybatis.io/info.html

优势

  • 高性能，单机每秒事务数最高可达456621Tps/s,总耗时0.22s （测试环境 返回模拟的sql数据，并发1000，总数100000，6核16GB win10）
  • 事务，session灵活插拔，兼容过渡期微服务
  • 异步日志异步消息队列日,框架内sql日志使用带缓存的channel实现 消息队列异步记录日志
  • 动态SQL，在xml中<select>,<update>,<insert>,<delete>,<trim>,<if>,<set>,<where>,<foreach>,<resultMap>,<bind>,<choose><when><otherwise>,<sql><include>等等java框架Mybatis包含的15种实用功能
  • 多数据库Mysql,Postgres,Tidb,SQLite,Oracle....等等更多
  • 无依赖基于反射动态代理,无需go generate生成*.go等中间代码，xml读取后可直接调用函数
  • 智能表达式#{foo.Bar}``#{arg+1}``#{arg*1}``#{arg/1}``#{arg-1}不但可以处理简单判断和计算任务，同时在取值时 假如foo.Bar 这个属性是指针,那么调用 foo.Bar 则会取指针指向的实际值,完全避免解引用操作
  • 动态数据源可以使用路由engine.SetDataSourceRouter自定义多数据源规则
  • 模板标签一行代码实现增删改查，逻辑删除，乐观锁（基于版本号更新）极大减轻CRUD操作的心智负担
  • 乐观锁<updateTemplete>支持通过修改版本号实现的乐观锁
  • 逻辑删除<insertTemplete>``<updateTemplete>``<deleteTemplete>``<selectTemplete>均支持逻辑删除
  • 8种事务传播行为复刻Spring MVC的事务传播行为功能
  • 定制easyrpc 基于rpc/jsonrpc让服务完美支持RPC（减少参数限制）,动态代理，事务订阅，易于微服务集成和扩展 详情请点击链接https://github.com/zhuxiujia/easyrpc

使用教程

示例源码https://github.com/zhuxiujia/GoMybatis/tree/master/example

设置好GoPath,用go get 命令下载GoMybatis和对应的数据库驱动

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

实际使用mapper

import (
	_ "github.com/go-sql-driver/mysql" //导入mysql驱动
	"GoMybatis"
	"fmt"
	"time"
)

//定义xml内容，建议以*Mapper.xml文件存于项目目录中,在编辑xml时就可享受GoLand等IDE渲染和智能提示。生产环境可以使用statikFS把xml文件打包进程序里

var xmlBytes = []byte(`
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"https://raw.githubusercontent.com/zhuxiujia/GoMybatis/master/mybatis-3-mapper.dtd">
<mapper namespace="ActivityMapperImpl">
    <!--SelectAll(result *[]Activity)error-->
    <select id="selectAll">
        select * from biz_activity where delete_flag=1 order by create_time desc
    </select>
</mapper>
`)

type ExampleActivityMapperImpl struct {
     SelectAll  func() ([]Activity, error)
}

func main() {
    var engine = GoMybatis.GoMybatisEngine{}.New()
	//Mysql链接格式 用户名:密码@(数据库链接地址:端口)/数据库名称,如root:123456@(***.com:3306)/test
	err := engine.Open("mysql", "*?charset=utf8&parseTime=True&loc=Local")
	if err != nil {
	   panic(err)
	}
	var exampleActivityMapperImpl ExampleActivityMapperImpl
	
	//加载xml实现逻辑到ExampleActivityMapperImpl
	engine.WriteMapperPtr(&exampleActivityMapperImpl, xmlBytes)

	//使用mapper
	result, err := exampleActivityMapperImpl.SelectAll(&result)
        if err != nil {
	   panic(err)
	}
	fmt.Println(result)
}

动态数据源

        //添加第二个mysql数据库,请把MysqlUri改成你的第二个数据源链接
	GoMybatis.Open("mysql", MysqlUri)
	//动态数据源路由
	var router = GoMybatis.GoMybatisDataSourceRouter{}.New(func(mapperName string) *string {
		//根据包名路由指向数据源
		if strings.Contains(mapperName, "example.") {
			var url = MysqlUri//第二个mysql数据库,请把MysqlUri改成你的第二个数据源链接
			fmt.Println(url)
			return &url
		}
		return nil
	})

自定义日志输出

	engine.SetLogEnable(true)
	engine.SetLog(&GoMybatis.LogStandard{
		PrintlnFunc: func(messages []byte) {
		},
	})

异步日志-基于消息队列日志

Image text 数据库驱动列表

 Mysql: github.com/go-sql-driver/mysql
 MyMysql: github.com/ziutek/mymysql/godrv
 Postgres: github.com/lib/pq
 Tidb: github.com/pingcap/tidb
 SQLite: github.com/mattn/go-sqlite3
 MsSql: github.com/denisenkom/go-mssqldb
 MsSql: github.com/lunny/godbc
 Oracle: github.com/mattn/go-oci8
 CockroachDB(Postgres): github.com/lib/pq

嵌套事务-事务传播行为

事务类型 说明
PROPAGATION_REQUIRED表示如果当前事务存在，则支持当前事务。否则，会启动一个新的事务。默认事务类型。
PROPAGATION_SUPPORTS表示如果当前事务存在，则支持当前事务，如果当前没有事务，就以非事务方式执行。
PROPAGATION_MANDATORY表示如果当前事务存在，则支持当前事务，如果当前没有事务，则返回事务嵌套错误。
PROPAGATION_REQUIRES_NEW表示新建一个全新Session开启一个全新事务，如果当前存在事务，则把当前事务挂起。
PROPAGATION_NOT_SUPPORTED表示以非事务方式执行操作，如果当前存在事务，则新建一个Session以非事务方式执行操作，把当前事务挂起。
PROPAGATION_NEVER表示以非事务方式执行操作，如果当前存在事务，则返回事务嵌套错误。
PROPAGATION_NESTED表示如果当前事务存在，则在嵌套事务内执行，如嵌套事务回滚，则只会在嵌套事务内回滚，不会影响当前事务。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。
PROPAGATION_NOT_REQUIRED表示如果当前没有事务，就新建一个事务,否则返回错误。

配套生态-搭配GoMybatis

  • https://github.com/zhuxiujia/easyrpc //easyrpc（基于标准库的RPC）吸收GoMybatis的概念，类似标准库的api，定义服务没有标准库的要求那么严格（可选不传参数，或者只有一个参数，只有一个返回值）
  • https://github.com/zhuxiujia/easyrpc_discovery //基于easyrpc定制微服务发现，支持动态代理，支持GoMybatis事务，AOP代理，事务嵌套，tag定义事务，自带负载均衡算法（随机，加权轮询，源地址哈希法） Image text

请及时关注版本，及时升级版本(新的功能，bug修复)

TODO 未来新特性（可能会更改）

  • 模板标签,一行代码crud（已完成）
  • 逻辑删除(已完成)
  • 乐观锁（已完成）
  • 重构SqlBuilder，使用抽象语法树代替递归，获得更好的维护性可读性(已完成)
  • Rust语言版本的 RustMybatis基于Rust语言和LLVM编译器不输于C++性能``无运行时``无GC``无,预期会在 -并发数,-内存消耗, 都将远超go语言版 (开发中) 敬请期待~

喜欢的老铁欢迎在右上角点下 star 关注和支持我们哈

Documentation

Index

Constants

View Source 
const Adapter_FormateDate = `2006-01-02 15:04:05`
View Source 
const DefaultOneArg = `[default]`
View Source 
const Element_Mapper = "mapper"
View Source 
const GoMybatis_Session = `GoMybatis.Session`
View Source 
const GoMybatis_Session_Ptr = `*GoMybatis.Session`
View Source 
const GoMybatis_Time = `time.Time`
View Source 
const GoMybatis_Time_Ptr = `*time.Time`
View Source 
const ID = `id`
View Source 
const NewSessionFunc = "NewSession" //NewSession method,auto write implement body code

Variables

View Source 
var (
	IntType   = reflect.TypeOf(c_INT_DEFAULT)
	Int8Type  = reflect.TypeOf(c_INT8_DEFAULT)
	Int16Type = reflect.TypeOf(c_INT16_DEFAULT)
	Int32Type = reflect.TypeOf(c_INT32_DEFAULT)
	Int64Type = reflect.TypeOf(c_INT64_DEFAULT)

	UintType   = reflect.TypeOf(c_UINT_DEFAULT)
	Uint8Type  = reflect.TypeOf(c_UINT8_DEFAULT)
	Uint16Type = reflect.TypeOf(c_UINT16_DEFAULT)
	Uint32Type = reflect.TypeOf(c_UINT32_DEFAULT)
	Uint64Type = reflect.TypeOf(c_UINT64_DEFAULT)

	Float32Type = reflect.TypeOf(c_FLOAT32_DEFAULT)
	Float64Type = reflect.TypeOf(c_FLOAT64_DEFAULT)

	Complex64Type  = reflect.TypeOf(c_COMPLEX64_DEFAULT)
	Complex128Type = reflect.TypeOf(c_COMPLEX128_DEFAULT)

	StringType = reflect.TypeOf(c_EMPTY_STRING)
	BoolType   = reflect.TypeOf(c_BOOL_DEFAULT)
	ByteType   = reflect.TypeOf(c_BYTE_DEFAULT)
	BytesType  = reflect.SliceOf(ByteType)

	TimeType = reflect.TypeOf(c_TIME_DEFAULT)
)
View Source 
var (
	PtrIntType   = reflect.PtrTo(IntType)
	PtrInt8Type  = reflect.PtrTo(Int8Type)
	PtrInt16Type = reflect.PtrTo(Int16Type)
	PtrInt32Type = reflect.PtrTo(Int32Type)
	PtrInt64Type = reflect.PtrTo(Int64Type)

	PtrUintType   = reflect.PtrTo(UintType)
	PtrUint8Type  = reflect.PtrTo(Uint8Type)
	PtrUint16Type = reflect.PtrTo(Uint16Type)
	PtrUint32Type = reflect.PtrTo(Uint32Type)
	PtrUint64Type = reflect.PtrTo(Uint64Type)

	PtrFloat32Type = reflect.PtrTo(Float32Type)
	PtrFloat64Type = reflect.PtrTo(Float64Type)

	PtrComplex64Type  = reflect.PtrTo(Complex64Type)
	PtrComplex128Type = reflect.PtrTo(Complex128Type)

	PtrStringType = reflect.PtrTo(StringType)
	PtrBoolType   = reflect.PtrTo(BoolType)
	PtrByteType   = reflect.PtrTo(ByteType)

	PtrTimeType = reflect.PtrTo(TimeType)
)

Functions

func AopProxyService 

func AopProxyService(service interface{}, engine SessionEngine)

使用AOP切面 代理目标服务，如果服务painc()它的事务会回滚 默认为单协程模型，如果是多协程调用的情况请开启engine.SetGoroutineIDEnable(true)

func AopProxyServiceValue 

func AopProxyServiceValue(service reflect.Value, engine SessionEngine)

使用AOP切面 代理目标服务，如果服务painc()它的事务会回滚

func LoadMapperXml 

func LoadMapperXml(bytes []byte) (items map[string]etree.Token)

func Proxy 

func Proxy(proxyPtr interface{}, buildFunc func(funcField reflect.StructField, field reflect.Value) func(arg ProxyArg) []reflect.Value)

AopProxy 可写入每个函数代理方法.proxyPtr:代理对象指针，buildFunc:构建代理函数

func ProxyValue 

func ProxyValue(mapperValue reflect.Value, buildFunc func(funcField reflect.StructField, field reflect.Value) func(arg ProxyArg) []reflect.Value)

AopProxy 可写入每个函数代理方法

func WriteMapper 

func WriteMapper(bean reflect.Value, xml []byte, sessionEngine SessionEngine)

写入方法内容，例如 

type ExampleActivityMapperImpl struct {
	SelectAll         func(result *[]Activity) error
	SelectByCondition func(name string, startTime time.Time, endTime time.Time, page int, size int, result *[]Activity) error `mapperParams:"name,startTime,endTime,page,size"`
	UpdateById        func(session *GoMybatis.Session, arg Activity, result *int64) error                                     //只要参数中包含有*GoMybatis.Session的类型，框架默认使用传入的session对象，用于自定义事务
	Insert            func(arg Activity, result *int64) error
	CountByCondition  func(name string, startTime time.Time, endTime time.Time, result *int) error `mapperParams:"name,startTime,endTime"`
}

func的基本类型的参数（例如string,int,time.Time,int64,float....）个数无限制(并且需要用Tag指定参数名逗号隔开,例如`mapperParams:"id,phone"`)，返回值必须有error func的结构体参数无需指定mapperParams的tag，框架会自动扫描它的属性，封装为map处理掉 使用WriteMapper函数设置代理后即可正常使用。

func WriteMapperByValue 

func WriteMapperByValue(value reflect.Value, xml []byte, sessionEngine SessionEngine)

推荐默认使用单例传入 根据sessionEngine写入到mapperPtr，value:指向mapper指针反射对象，xml：xml数据，sessionEngine：session引擎，enableLog:是否允许日志输出，log：日志实现

func WriteMapperPtrByEngine 

func WriteMapperPtrByEngine(ptr interface{}, xml []byte, sessionEngine SessionEngine)

推荐默认使用单例传入 根据sessionEngine写入到mapperPtr，ptr:指向mapper指针，xml：xml数据，sessionEngine：session引擎，enableLog:是否允许日志输出，log：日志实现

Types

type CallBack 

type CallBack struct {
	//sql 查询之前执行，可以写指针改变sql内容(func 可以为nil)
	BeforeQuery func(args []reflect.Value, sqlorArgs *string)
	//sql 查询之前执行，可以写指针改变sql内容(func 可以为nil)
	BeforeExec func(args []reflect.Value, sqlorArgs *string)

	//sql 查询之后执行，可以写指针改变返回结果(func 可以为nil)
	AfterQuery func(args []reflect.Value, sqlorArgs string, result *[]map[string][]byte, err *error)
	//sql 查询之后执行，可以写指针改变返回结果(func 可以为nil)
	AfterExec func(args []reflect.Value, sqlorArgs string, result *Result, err *error)
}

sql 运行时 回调

type DataSourceRouter 

type DataSourceRouter interface {
	//路由规则
	//参数：mapperName mapper文件包名+名称例如（example.ExampleActivityMapper）
	//返回（session,error）路由选择后的session，error异常
	Router(mapperName string, engine SessionEngine) (Session, error)
	//设置sql.DB，该方法会被GoMybatis框架内调用
	SetDB(driver string, url string, db *sql.DB)

	Name() string
}

数据源路由接口

type ElementType 

type ElementType = string
const (
	//root elements
	Element_ResultMap ElementType = "resultMap"
	Element_Insert    ElementType = "insert"
	Element_Delete    ElementType = "delete"
	Element_Update    ElementType = `update`
	Element_Select    ElementType = "select"
	Element_Sql       ElementType = "sql"

	//root templete elements
	Element_Insert_Templete ElementType = "insertTemplete"
	Element_Delete_Templete ElementType = "deleteTemplete"
	Element_Update_Templete ElementType = `updateTemplete`
	Element_Select_Templete ElementType = "selectTemplete"

	//child elements
	Element_bind      ElementType = "bind"
	Element_String    ElementType = "string"
	Element_If        ElementType = `if`
	Element_Trim      ElementType = "trim"
	Element_Foreach   ElementType = "foreach"
	Element_Set       ElementType = "set"
	Element_choose    ElementType = "choose"
	Element_when      ElementType = "when"
	Element_otherwise ElementType = "otherwise"
	Element_where     ElementType = "where"
	Element_Include   ElementType = "include"
)

type ExpressionEngineLexerCache 

type ExpressionEngineLexerCache interface {
	Set(expression string, lexer interface{}) error
	Get(expression string) (interface{}, error)
	Name() string
}

Lexer 结果缓存

type ExpressionEngineLexerCacheable 

type ExpressionEngineLexerCacheable interface {
	SetUseLexerCache(use bool) error
	LexerCacheable() bool
}

type ExpressionEngineLexerMapCache 

type ExpressionEngineLexerMapCache struct {
	// contains filtered or unexported fields
}

func (*ExpressionEngineLexerMapCache) Get 

func (it *ExpressionEngineLexerMapCache) Get(expression string) (interface{}, error)

func (*ExpressionEngineLexerMapCache) Name 

func (it *ExpressionEngineLexerMapCache) Name() string

func (ExpressionEngineLexerMapCache) New 

func (it ExpressionEngineLexerMapCache) New() ExpressionEngineLexerMapCache

func (*ExpressionEngineLexerMapCache) Set 

func (it *ExpressionEngineLexerMapCache) Set(expression string, lexer interface{}) error

type ExpressionEngineProxy 

type ExpressionEngineProxy struct {
	// contains filtered or unexported fields
}

func (*ExpressionEngineProxy) Eval 

func (it *ExpressionEngineProxy) Eval(lexerResult interface{}, arg interface{}, operation int) (interface{}, error)

执行一个表达式 参数：lexerResult=编译结果，arg=参数 返回：执行结果，错误

func (*ExpressionEngineProxy) Lexer 

func (it *ExpressionEngineProxy) Lexer(expression string) (interface{}, error)

编译一个表达式 参数：lexerArg 表达式内容 返回：interface{} 编译结果,error 错误

func (*ExpressionEngineProxy) LexerAndEval 

func (it *ExpressionEngineProxy) LexerAndEval(expression string, arg interface{}) (interface{}, error)

执行

func (*ExpressionEngineProxy) LexerCache 

func (it *ExpressionEngineProxy) LexerCache() ExpressionEngineLexerCache

func (*ExpressionEngineProxy) LexerCacheable 

func (it *ExpressionEngineProxy) LexerCacheable() bool

func (ExpressionEngineProxy) Name 

func (it ExpressionEngineProxy) Name() string

引擎名称

func (ExpressionEngineProxy) New 

func (ExpressionEngineProxy) New(engine ast.ExpressionEngine, useLexerCache bool) ExpressionEngineProxy

engine ：表达式引擎,useLexerCache：是否缓存Lexer表达式编译结果

func (*ExpressionEngineProxy) SetExpressionEngine 

func (it *ExpressionEngineProxy) SetExpressionEngine(engine ast.ExpressionEngine)

引擎名称

func (*ExpressionEngineProxy) SetLexerCache 

func (it *ExpressionEngineProxy) SetLexerCache(cache ExpressionEngineLexerCache)

func (*ExpressionEngineProxy) SetUseLexerCache 

func (it *ExpressionEngineProxy) SetUseLexerCache(isUseCache bool) error

type GoMybatisDataSourceRouter 

type GoMybatisDataSourceRouter struct {
	// contains filtered or unexported fields
}

动态数据源路由

func (*GoMybatisDataSourceRouter) Name 

func (it *GoMybatisDataSourceRouter) Name() string

func (GoMybatisDataSourceRouter) New 

func (it GoMybatisDataSourceRouter) New(routerFunc func(mapperName string) *string) GoMybatisDataSourceRouter

初始化路由，routerFunc为nil或者routerFunc返回nil，则框架自行选择第一个数据库作为数据源

func (*GoMybatisDataSourceRouter) Router 

func (it *GoMybatisDataSourceRouter) Router(mapperName string, engine SessionEngine) (Session, error)

func (*GoMybatisDataSourceRouter) SetDB 

func (it *GoMybatisDataSourceRouter) SetDB(driver string, url string, db *sql.DB)

type GoMybatisEngine 

type GoMybatisEngine struct {
	// contains filtered or unexported fields
}

func (*GoMybatisEngine) DataSourceRouter 

func (it *GoMybatisEngine) DataSourceRouter() DataSourceRouter

func (*GoMybatisEngine) ExpressionEngine 

func (it *GoMybatisEngine) ExpressionEngine() ast.ExpressionEngine

表达式执行引擎

func (*GoMybatisEngine) GetObj 

func (it *GoMybatisEngine) GetObj(name string) interface{}

func (*GoMybatisEngine) GoroutineIDEnable 

func (it *GoMybatisEngine) GoroutineIDEnable() bool

func (*GoMybatisEngine) GoroutineSessionMap 

func (it *GoMybatisEngine) GoroutineSessionMap() *GoroutineSessionMap

func (*GoMybatisEngine) Log 

func (it *GoMybatisEngine) Log() Log

获取日志实现类

func (*GoMybatisEngine) LogEnable 

func (it *GoMybatisEngine) LogEnable() bool

获取日志实现类，是否启用日志

func (*GoMybatisEngine) LogSystem 

func (it *GoMybatisEngine) LogSystem() *LogSystem

func (*GoMybatisEngine) Name 

func (it *GoMybatisEngine) Name() string

func (GoMybatisEngine) New 

func (it GoMybatisEngine) New() GoMybatisEngine

func (*GoMybatisEngine) NewSession 

func (it *GoMybatisEngine) NewSession(mapperName string) (Session, error)

func (*GoMybatisEngine) Open 

func (it *GoMybatisEngine) Open(driverName, dataSourceName string) (*sql.DB, error)

打开数据库 driverName: 驱动名称例如"mysql", dataSourceName: string 数据库url

func (*GoMybatisEngine) RegisterObj 

func (it *GoMybatisEngine) RegisterObj(ptr interface{}, name string)

func (*GoMybatisEngine) SessionFactory 

func (it *GoMybatisEngine) SessionFactory() *SessionFactory

session工厂

func (*GoMybatisEngine) SetDataSourceRouter 

func (it *GoMybatisEngine) SetDataSourceRouter(router DataSourceRouter)

func (*GoMybatisEngine) SetExpressionEngine 

func (it *GoMybatisEngine) SetExpressionEngine(engine ast.ExpressionEngine)

设置表达式执行引擎

func (*GoMybatisEngine) SetGoroutineIDEnable 

func (it *GoMybatisEngine) SetGoroutineIDEnable(enable bool)

func (*GoMybatisEngine) SetLog 

func (it *GoMybatisEngine) SetLog(log Log)

设置日志实现类

func (*GoMybatisEngine) SetLogEnable 

func (it *GoMybatisEngine) SetLogEnable(enable bool)

设置日志实现类，是否启用日志

func (*GoMybatisEngine) SetSessionFactory 

func (it *GoMybatisEngine) SetSessionFactory(factory *SessionFactory)

设置session工厂

func (*GoMybatisEngine) SetSqlArgTypeConvert 

func (it *GoMybatisEngine) SetSqlArgTypeConvert(convert ast.SqlArgTypeConvert)

设置sql类型转换器

func (*GoMybatisEngine) SetSqlBuilder 

func (it *GoMybatisEngine) SetSqlBuilder(builder SqlBuilder)

设置sql构建器

func (*GoMybatisEngine) SetSqlResultDecoder 

func (it *GoMybatisEngine) SetSqlResultDecoder(decoder SqlResultDecoder)

设置sql查询结果解析器

func (*GoMybatisEngine) SetTempleteDecoder 

func (it *GoMybatisEngine) SetTempleteDecoder(decoder TempleteDecoder)

设置模板解析器

func (*GoMybatisEngine) SqlArgTypeConvert 

func (it *GoMybatisEngine) SqlArgTypeConvert() ast.SqlArgTypeConvert

sql类型转换器

func (*GoMybatisEngine) SqlBuilder 

func (it *GoMybatisEngine) SqlBuilder() SqlBuilder

sql构建器

func (*GoMybatisEngine) SqlResultDecoder 

func (it *GoMybatisEngine) SqlResultDecoder() SqlResultDecoder

sql查询结果解析器

func (*GoMybatisEngine) TempleteDecoder 

func (it *GoMybatisEngine) TempleteDecoder() TempleteDecoder

模板解析器

func (*GoMybatisEngine) WriteMapperPtr 

func (it *GoMybatisEngine) WriteMapperPtr(ptr interface{}, xml []byte)

type GoMybatisSqlArgTypeConvert 

type GoMybatisSqlArgTypeConvert struct {
}

Sql内容类型转换器

func (GoMybatisSqlArgTypeConvert) Convert 

func (it GoMybatisSqlArgTypeConvert) Convert(argValue interface{}, argType reflect.Type) string

Sql内容类型转换器

type GoMybatisSqlBuilder 

type GoMybatisSqlBuilder struct {
	// contains filtered or unexported fields
}

func (*GoMybatisSqlBuilder) BuildSql 

func (it *GoMybatisSqlBuilder) BuildSql(paramMap map[string]interface{}, nodes []ast.Node) (string, error)

func (*GoMybatisSqlBuilder) EnableLog 

func (it *GoMybatisSqlBuilder) EnableLog() bool

func (*GoMybatisSqlBuilder) ExpressionEngineProxy 

func (it *GoMybatisSqlBuilder) ExpressionEngineProxy() *ExpressionEngineProxy

func (GoMybatisSqlBuilder) New 

func (it GoMybatisSqlBuilder) New(SqlArgTypeConvert ast.SqlArgTypeConvert, expressionEngine ExpressionEngineProxy, log Log, enableLog bool) GoMybatisSqlBuilder

func (*GoMybatisSqlBuilder) NodeParser 

func (it *GoMybatisSqlBuilder) NodeParser() ast.NodeParser

func (*GoMybatisSqlBuilder) SetEnableLog 

func (it *GoMybatisSqlBuilder) SetEnableLog(enable bool)

func (*GoMybatisSqlBuilder) SqlArgTypeConvert 

func (it *GoMybatisSqlBuilder) SqlArgTypeConvert() ast.SqlArgTypeConvert

type GoMybatisSqlResultDecoder 

type GoMybatisSqlResultDecoder struct {
	SqlResultDecoder
}

func (GoMybatisSqlResultDecoder) Decode 

func (it GoMybatisSqlResultDecoder) Decode(resultMap map[string]*ResultProperty, sqlResult []map[string][]byte, result interface{}) error

type GoMybatisTempleteDecoder 

type GoMybatisTempleteDecoder struct {
}

* TODO sqlTemplete解析器，目前直接操作*etree.Element实现，后期应该改成操作xml，换取更好的维护性

func (*GoMybatisTempleteDecoder) Decode 

func (it *GoMybatisTempleteDecoder) Decode(method *reflect.StructField, mapper *etree.Element, tree map[string]etree.Token) error

func (*GoMybatisTempleteDecoder) DecodeSets 

func (it *GoMybatisTempleteDecoder) DecodeSets(arg string, mapper *etree.Element, logic LogicDeleteData, versionData *VersionData)

func (*GoMybatisTempleteDecoder) DecodeTree 

func (it *GoMybatisTempleteDecoder) DecodeTree(tree map[string]etree.Token, beanType reflect.Type) error

func (*GoMybatisTempleteDecoder) DecodeWheres 

func (it *GoMybatisTempleteDecoder) DecodeWheres(arg string, mapper *etree.Element, logic LogicDeleteData, versionData *VersionData)

解码逗号分隔的where

type GoroutineSessionMap 

type GoroutineSessionMap struct {
	// contains filtered or unexported fields
}

func (*GoroutineSessionMap) Delete 

func (it *GoroutineSessionMap) Delete(k int64)

func (*GoroutineSessionMap) Get 

func (it *GoroutineSessionMap) Get(k int64) Session

func (GoroutineSessionMap) New 

func (it GoroutineSessionMap) New() GoroutineSessionMap

func (*GoroutineSessionMap) Put 

func (it *GoroutineSessionMap) Put(k int64, session Session)

type LocalSession 

type LocalSession struct {
	SessionId string
	// contains filtered or unexported fields
}

本地直连session

func (*LocalSession) Begin 

func (it *LocalSession) Begin(p *tx.Propagation) error

func (*LocalSession) Close 

func (it *LocalSession) Close()

func (*LocalSession) Commit 

func (it *LocalSession) Commit() error

func (*LocalSession) Exec 

func (it *LocalSession) Exec(sqlorArgs string) (*Result, error)

func (*LocalSession) Id 

func (it *LocalSession) Id() string

func (LocalSession) New 

func (it LocalSession) New(driver string, url string, db *sql.DB, logSystem Log) LocalSession

func (*LocalSession) Query 

func (it *LocalSession) Query(sqlorArgs string) ([]map[string][]byte, error)

func (*LocalSession) Rollback 

func (it *LocalSession) Rollback() error

type Log 

type Log interface {
	QueueLen() int           //日志消息队列长度
	Println(messages []byte) //日志输出方法实现
}

type LogStandard 

type LogStandard struct {
	PrintlnFunc func(messages []byte) //日志输出方法实现
}

func (*LogStandard) Println 

func (it *LogStandard) Println(v []byte)

日志输出方法实现

func (*LogStandard) QueueLen 

func (it *LogStandard) QueueLen() int

日志消息队列长度

type LogSystem 

type LogSystem struct {
	// contains filtered or unexported fields
}

func (*LogSystem) Close 

func (it *LogSystem) Close() error

关闭日志系统和队列

func (LogSystem) New 

func (it LogSystem) New(logImpl Log, queueLen int) (LogSystem, error)

logImpl:日志实现类,queueLen:消息队列缓冲长度

func (*LogSystem) SendLog 

func (it *LogSystem) SendLog(logs ...string) error

日志发送者

type LogicDeleteData 

type LogicDeleteData struct {
	Column   string
	Property string
	LangType string

	Enable         bool
	Deleted_value  string
	Undelete_value string
}

type Mapper 

type Mapper struct {
	// contains filtered or unexported fields
}

type ProxyArg 

type ProxyArg struct {
	TagArgs    []TagArg
	TagArgsLen int
	Args       []reflect.Value
	ArgsLen    int
}

代理数据

func (ProxyArg) New 

func (it ProxyArg) New(tagArgs []TagArg, args []reflect.Value) ProxyArg

type Result 

type Result struct {
	LastInsertId int64
	RowsAffected int64
}

type ResultProperty 

type ResultProperty struct {
	XMLName  string //`xml:"result/id"`
	Column   string
	Property string
	GoType   string
}

type ReturnType 

type ReturnType struct {
	ErrorType     *reflect.Type
	ReturnOutType *reflect.Type
	ReturnIndex   int //返回数据位置索引
	NumOut        int //返回总数
}

type Session 

type Session interface {
	Id() string
	Query(sqlorArgs string) ([]map[string][]byte, error)
	Exec(sqlorArgs string) (*Result, error)
	Rollback() error
	Commit() error
	Begin(p *tx.Propagation) error
	Close()
}

type SessionEngine 

type SessionEngine interface {
	//打开数据库
	Open(driverName, dataSourceName string) (*sql.DB, error)
	//写方法到mapper
	WriteMapperPtr(ptr interface{}, xml []byte)
	//引擎名称
	Name() string
	//创建session
	NewSession(mapperName string) (Session, error)
	//获取数据源路由
	DataSourceRouter() DataSourceRouter
	//设置数据源路由
	SetDataSourceRouter(router DataSourceRouter)

	//是否启用日志
	LogEnable() bool

	//是否启用日志
	SetLogEnable(enable bool)

	//获取日志实现类
	Log() Log

	//设置日志实现类
	SetLog(log Log)

	//session工厂
	SessionFactory() *SessionFactory

	//设置session工厂
	SetSessionFactory(factory *SessionFactory)

	//sql类型转换器
	SqlArgTypeConvert() ast.SqlArgTypeConvert

	//设置sql类型转换器
	SetSqlArgTypeConvert(convert ast.SqlArgTypeConvert)

	//表达式执行引擎
	ExpressionEngine() ast.ExpressionEngine

	//设置表达式执行引擎
	SetExpressionEngine(engine ast.ExpressionEngine)

	//sql构建器
	SqlBuilder() SqlBuilder

	//设置sql构建器
	SetSqlBuilder(builder SqlBuilder)

	//sql查询结果解析器
	SqlResultDecoder() SqlResultDecoder

	//设置sql查询结果解析器
	SetSqlResultDecoder(decoder SqlResultDecoder)

	//模板解析器
	TempleteDecoder() TempleteDecoder

	//设置模板解析器
	SetTempleteDecoder(decoder TempleteDecoder)

	RegisterObj(ptr interface{}, name string)

	GetObj(name string) interface{}

	//（注意（该方法需要在多协程环境下调用）启用会从栈获取协程id，有一定性能消耗，换取最大的事务定义便捷）
	GoroutineSessionMap() *GoroutineSessionMap

	//是否启用goroutineIDEnable（注意（该方法需要在多协程环境下调用）启用会从栈获取协程id，有一定性能消耗，换取最大的事务定义便捷）
	SetGoroutineIDEnable(enable bool)

	//是否启用goroutineIDEnable（注意（该方法需要在多协程环境下调用）启用会从栈获取协程id，有一定性能消耗，换取最大的事务定义便捷）
	GoroutineIDEnable() bool

	LogSystem() *LogSystem
}

产生session的引擎

type SessionFactory 

type SessionFactory struct {
	Engine     SessionEngine
	SessionMap map[string]Session
}

func (*SessionFactory) Close 

func (it *SessionFactory) Close(id string)

func (*SessionFactory) CloseAll 

func (it *SessionFactory) CloseAll(id string)

func (*SessionFactory) GetSession 

func (it *SessionFactory) GetSession(id string) Session

func (SessionFactory) New 

func (it SessionFactory) New(Engine SessionEngine) SessionFactory

func (*SessionFactory) NewSession 

func (it *SessionFactory) NewSession(mapperName string, sessionType SessionType) Session

func (*SessionFactory) SetSession 

func (it *SessionFactory) SetSession(id string, session Session)

type SessionFactorySession 

type SessionFactorySession struct {
	Session Session
	Factory *SessionFactory
}

func (*SessionFactorySession) Begin 

func (it *SessionFactorySession) Begin(p *tx.Propagation) error

func (*SessionFactorySession) Close 

func (it *SessionFactorySession) Close()

func (*SessionFactorySession) Commit 

func (it *SessionFactorySession) Commit() error

func (*SessionFactorySession) Exec 

func (it *SessionFactorySession) Exec(sqlorArgs string) (*Result, error)

func (*SessionFactorySession) Id 

func (it *SessionFactorySession) Id() string

func (*SessionFactorySession) Query 

func (it *SessionFactorySession) Query(sqlorArgs string) ([]map[string][]byte, error)

func (*SessionFactorySession) Rollback 

func (it *SessionFactorySession) Rollback() error

type SessionSupport 

type SessionSupport struct {
	NewSession func() (Session, error) //session为事务操作
}

type SessionType 

type SessionType = int
const (
	SessionType_Default SessionType = iota //默认session类型
	SessionType_Local                      //本地session
)

type SqlBuilder 

type SqlBuilder interface {
	BuildSql(paramMap map[string]interface{}, nodes []ast.Node) (string, error)
	ExpressionEngineProxy() *ExpressionEngineProxy
	SqlArgTypeConvert() ast.SqlArgTypeConvert
	SetEnableLog(enable bool)
	EnableLog() bool
	NodeParser() ast.NodeParser
}

sql文本构建

type SqlResultDecoder 

type SqlResultDecoder interface {
	//resultMap = in xml resultMap element
	//dbData = select the SqlResult
	//decodeResultPtr = need decode result type
	Decode(resultMap map[string]*ResultProperty, SqlResult []map[string][]byte, decodeResultPtr interface{}) error
}

sql查询结果解码

type TagArg 

type TagArg struct {
	Name  string
	Index int
}

type TempleteDecoder 

type TempleteDecoder interface {
	DecodeTree(tree map[string]etree.Token, beanType reflect.Type) error
}

type VersionData 

type VersionData struct {
	Column   string
	Property string
	LangType string
}

Source Files

View all Source files

Directories

Path Synopsis
lib
github.com/Knetic/govaluate
github.com/antonmedv/expr
Package expr is an engine that can evaluate expressions.
 Package expr is an engine that can evaluate expressions.
github.com/beevik/etree
Package etree provides XML services through an Element Tree abstraction.
 Package etree provides XML services through an Element Tree abstraction.
github.com/nytlabs/gojee
github.com/nytlabs/gojee/jee
github.com/zhuxiujia/GoFastExpress

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.