gobatis

package module
v0.0.0-...-90fccff Latest Latest
Warning

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

 Go to latest Published: Apr 2, 2024 License: Apache-2.0 Imports: 20 Imported by: 0

README

gobatis

目前代码都是基于类mysql数据库编写测试的,其他数据库暂时还未做兼容处理

  • 支持数据库
    • mysql
    • clickhouse
    • postgres
  • 基础操作
    • query
    • insert
    • update
    • delete

ToDo

  • 增加更多易用表达式指令，目前已有$blank指令用于判别字符串是否为空的指令，比如判断name为空串： test="$blank(name)"

gobatis接口

type GoBatis interface {
	// Select 查询数据
	Select(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)
	// SelectContext 查询数据with context
	SelectContext(ctx context.Context, stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)
	// Insert 插入数据
	Insert(stmt string, param interface{}) (lastInsertId int64, affected int64, err error)
	// InsertContext 插入数据with context
	InsertContext(ctx context.Context, stmt string, param interface{}) (lastInsertId int64, affected int64, err error)
	// Update 更新数据
	Update(stmt string, param interface{}) (affected int64, err error)
	// UpdateContext 更新数据with context
	UpdateContext(ctx context.Context, stmt string, param interface{}) (affected int64, err error)
	// Delete 刪除数据
	Delete(stmt string, param interface{}) (affected int64, err error)
	// DeleteContext 刪除数据with context
	DeleteContext(ctx context.Context, stmt string, param interface{}) (affected int64, err error)
}
  • mapper配置
  1. mapper可以配置namespace属性
  2. mapper可以包含: select, insert, update, delete标签
  3. mapper子标签id属性则为标签唯一标识, 必须配置属性
  4. 其中select标签必须包含resultType属性，resultType可以是: map, maps, array, arrays, struct, structs, value

  • 标签说明
    select: 用于查询操作
    insert: 用于插入sql操作
    update: 用于更新sql操作
    delete: 用于删除sql操作

  • resultType说明
    map: 则数据库查询结果为map
    maps: 则数据库查询结果为map数组
    array: 则数据库查询结果为值数组
    arrays: 则数据库查询结果为多个值数组
    struct: 则数据库查询结果为单个结构体
    structs: 则数据库查询结果为结构体数组
    value: 则数据库查询结果为单个数值

以下是mapper配置示例: mapper/userMapper.xml

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE mapper PUBLIC "gobatis" "https://raw.githubusercontent.com/hanwbcode/gobatis/main/gobatis.dtd">
<mapper namespace="userMapper">
    <sql id="Base_Column_List">
        id, name, crtTm, pwd, email
    </sql>
    <select id="findIncludeMaps" resultType="maps">
        SELECT
        	<include refid="Base_Column_List" />
        FROM user
        limit 10
    </select>
    <select id="findMapById" resultType="map">
        SELECT id, name FROM user where id=#{id} order by id
    </select>
    <select id="findMapByValue" resultType="map">
            SELECT id, name FROM user where id=#{0} order by id
    </select>
    <select id="findStructByStruct" resultType="struct">
        SELECT id, name, crtTm FROM user where id=#{Id} order by id
    </select>
    <select id="queryStructs" resultType="structs">
        SELECT id, name, crtTm FROM user order by id
    </select>
    <select id="queryStructsByOrder" resultType="structs">
        SELECT id, name, crtTm FROM user order by ${id} desc
    </select>
    <insert id="insertStruct">
        insert into user (name, email, crtTm)
        values (#{Name}, #{Email}, #{CrtTm})
    </insert>
    <delete id="deleteById">
        delete from user where id=#{id}
    </delete>
    <select id="queryStructsByCond" resultType="structs">
         SELECT id, name, crtTm, pwd, email FROM user
         <where>
             <if test="!$blank(Name)">and name = #{Name}</if>
         </where>
         order by id
    </select>
     <select id="queryStructsByCond2" resultType="structs">
         SELECT id, name, crtTm, pwd, email FROM user
         <trim prefixOverrides="and" prefix="where" suffixOverrides="," suffix="and 1=1">
              <if test="!$blank(Name)">and name = #{Name}</if>
         </trim>
         order by id
    </select>
    <update id="updateByCond">
        update user
        <set>
            <if test="!$blank(Name) and !$blank(Name2)">name = #{Name},</if>
        </set>
        where id = #{Id}
    </update>
</mapper>

使用方法

使用配置文件配置

example1.go

package main

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql" // 引入驱动
	"github.com/hanwbcode/gobatis"        // 引入gobatis
)

// 实体结构示例， tag：field为数据库对应字段名称
type User struct {
	Id    gobatis.NullInt64  `field:"id"`
	Name  gobatis.NullString `field:"name"`
	Email gobatis.NullString `field:"email"`
	CrtTm gobatis.NullTime   `field:"crtTm"`
}


// User to string
func (u *User) String() string {
	bs, _ := json.Marshal(u)
	return string(bs)
}

func main() {
	// 初始化db，参数为db.yml路径，如：db.yml	
	gobatis.Init(gobatis.NewFileOption("db.yml"))

	// 获取数据源，参数为数据源名称，如：datasource1
	gb := gobatis.Get("ds1")

	//传入id查询Map
	mapRes := make(map[string]interface{})
	// stmt标识为：namespace + '.' + id, 如：userMapper.findMapById
	// 查询参数可以是map，也可以是数组，也可以是实体结构
	_, err := gb.Select("userMapper.findMapById", map[string]interface{}{"id": 1})(mapRes)
	fmt.Println("userMapper.findMapById-->", mapRes, err)

	// 根据传入实体查询对象
	param := User{Id: gobatis.NullInt64{Int64: 1, Valid: true}}
	var structRes *User
	_, err = gb.Select("userMapper.findStructByStruct", param)(&structRes)
	fmt.Println("userMapper.findStructByStruct-->", structRes, err)

	// 查询实体列表
	structsRes := make([]*User, 0)
	_, err = gb.Select("userMapper.queryStructs", map[string]interface{}{})(&structsRes)
	fmt.Println("userMapper.queryStructs-->", structsRes, err)

	param = User{
		Id:   gobatis.NullInt64{Int64: 1, Valid: true},
		Name: gobatis.NullString{String: "test3", Valid: true},
	}

	// set tag
	affected, err := gb.Update("userMapper.updateByCond", param)
	fmt.Println("updateByCond:", affected, err)

	param = User{Name: gobatis.NullString{String: "test3", Valid: true}}
	// where tag
	res := make([]*User, 0)
	_, err = gb.Select("userMapper.queryStructsByCond", param)(&res)
	fmt.Println("queryStructsByCond", res, err)

	// trim tag
	res = make([]*User, 0)
	_, err = gb.Select("userMapper.queryStructsByCond2", param)(&res)
	fmt.Println("queryStructsByCond2", res, err)

	// include tag
	ms := make([]map[string]interface{}, 0)
	_, err = gb.Select("userMapper.findIncludeMaps", nil)(&ms)
	fmt.Println("userMapper.findIncludeMaps-->", ms, err)
	
	// ${id}
	res = make([]*User, 0)
	_, err = gb.Select("userMapper.queryStructsByOrder", map[string]interface{}{
		"id":"id",
	})(&res)
	fmt.Println("queryStructsByCond", res, err)

	// ${id} with count, 传入RowBounds(0, 100)即可返回count总数
	res = make([]*User, 0)
	cnt, err = gb.Select("userMapper.queryStructsByOrder", map[string]interface{}{
		"id":"id",
	}, RowBounds(0, 100))(&res)
	fmt.Println("queryStructsByCond", cnt, res, err)


	// 开启事务示例
	tx, _ := gb.Begin()
	defer tx.Rollback()
	_, tx.Select("userMapper.findMapById", map[string]interface{}{"id": 1,})(mapRes)
	fmt.Println("tx userMapper.findMapById-->", mapRes, err)
	tx.Commit()
}
代码配置方式

example2.go

package main

import (
	"fmt"
	_ "github.com/go-sql-driver/mysql" // 引入驱动
	"github.com/hanwbcode/gobatis"        // 引入gobatis
)

// 实体结构示例， tag：field为数据库对应字段名称
type User struct {
	Id    gobatis.NullInt64  `field:"id"`
	Name  gobatis.NullString `field:"name"`
	Email gobatis.NullString `field:"email"`
	CrtTm gobatis.NullTime   `field:"crtTm"`
}

func main() {
	// 初始化db
	ds1 := gobatis.NewDataSourceBuilder().
		DataSource("ds1").
		DriverName("mysql").
		DataSourceName("root:123456@tcp(127.0.0.1:3306)/test?charset=utf8").
		MaxLifeTime(120).
		MaxOpenConns(10).
		MaxIdleConns(5).
		Build()

	option := gobatis.NewDSOption().
		DS([]*gobatis.DataSource{ds1}).
		Mappers([]string{"examples/mapper/userMapper.xml"}).
		ShowSQL(true)

	gobatis.Init(option)

	// 获取数据源，参数为数据源名称，如：ds1
	gb := gobatis.Get("ds1")

	//传入id查询Map
	mapRes := make(map[string]interface{})
	// stmt标识为：namespace + '.' + id, 如：userMapper.findMapById
	// 查询参数可以是map，也可以是数组，也可以是实体结构
	_, err := gb.Select("userMapper.findMapById", map[string]interface{}{"id": 1})(mapRes)
	fmt.Println("userMapper.findMapById-->", mapRes, err)
}

example3.go

package main

import (
	"database/sql"
	"fmt"
	_ "github.com/go-sql-driver/mysql" // 引入驱动
	"github.com/hanwbcode/gobatis"        // 引入gobatis
)

// 实体结构示例， tag：field为数据库对应字段名称
type User struct {
	Id    gobatis.NullInt64  `field:"id"`
	Name  gobatis.NullString `field:"name"`
	Email gobatis.NullString `field:"email"`
	CrtTm gobatis.NullTime   `field:"crtTm"`
}

func main() {
	// 初始化db
	db, _ := sql.Open("mysql", "root:123456@tcp(127.0.0.1:3306)/test?charset=utf8")
	dbs := make(map[string]*gobatis.GoBatisDB)
	dbs["ds1"] = gobatis.NewGoBatisDB(gobatis.DBTypeMySQL, db)

	option := gobatis.NewDBOption().
		DB(dbs).
		ShowSQL(true).
		Mappers([]string{"examples/mapper/userMapper.xml"})

	gobatis.Init(option)

	// 获取数据源，参数为数据源名称，如：ds1
	gb := gobatis.Get("ds1")

	//传入id查询Map
	mapRes := make(map[string]interface{})
	// stmt标识为：namespace + '.' + id, 如：userMapper.findMapById
	// 查询参数可以是map，也可以是数组，也可以是实体结构
	_, err := gb.Select("userMapper.findMapById", map[string]interface{}{"id": 1})(mapRes)
	fmt.Println("userMapper.findMapById-->", mapRes, err)
}

致谢

感谢jetbrains提供的goland！

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Init 

func Init(option IOption)

func NewStack 

func NewStack() *stack

func PB 

func PB(b bool) *bool

NB to NullBool

func PF64 

func PF64(f float64) *float64

PF64 to NullFloat64

func PI64 

func PI64(i int64) *int64

PI64 to NullInt64

func PS 

func PS(s string) *string

PS to NullString

func PT 

func PT(t time.Time) *time.Time

PT to NullTime

func Parse 

func Parse(r io.Reader) *node

func RowBounds 

func RowBounds(offset int, limit int) *rowBounds

func SetLogger 

func SetLogger(log ILogger)

Types

type DB 

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

DB

func Get 

func Get(datasource string) *DB

func (*DB) Begin 

func (d *DB) Begin() (*sql.Tx, error)

Begin TX

ps： 

TX, err := this.Begin()

func (*DB) BeginTx 

func (d *DB) BeginTx(ctx context.Context, opts *sql.TxOptions) (*sql.Tx, error)

Begin TX with ctx & opts

ps： 

TX, err := this.BeginTx(ctx, ops)

func (*DB) Close 

func (g *DB) Close() error

Close db

ps： 

err := this.Close()

func (*DB) Delete 

func (g *DB) Delete(stmt string, param interface{}) (int64, error)

delete(stmt string, param interface{})

func (*DB) DeleteContext 

func (g *DB) DeleteContext(ctx context.Context, stmt string, param interface{}) (int64, error)

func (*DB) Insert 

func (g *DB) Insert(stmt string, param interface{}) (int64, int64, error)

insert(stmt string, param interface{})

func (*DB) InsertBatch 

func (g *DB) InsertBatch(stmt string, param interface{}) (int64, int64, error)

func (*DB) InsertContext 

func (g *DB) InsertContext(ctx context.Context, stmt string, param interface{}) (int64, int64, error)

func (*DB) Select 

func (g *DB) Select(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

reference from https://github.com/yinshuwei/osm/blob/master/osm.go end

func (*DB) SelectContext 

func (g *DB) SelectContext(ctx context.Context, stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

func (*DB) SelectV2 

func (g *DB) SelectV2(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

func (*DB) Transaction 

func (d *DB) Transaction(fn func(tx *sql.Tx) error) error

Transaction tx

func (*DB) TransactionTX 

func (d *DB) TransactionTX(ctx context.Context, opts *sql.TxOptions, fn func(tx *sql.Tx) error) error

Transaction tx

func (*DB) Update 

func (g *DB) Update(stmt string, param interface{}) (int64, error)

update(stmt string, param interface{})

func (*DB) UpdateContext 

func (g *DB) UpdateContext(ctx context.Context, stmt string, param interface{}) (int64, error)

type DBConfig 

type DBConfig struct {
	DB      []*DataSource `yaml:"db"`
	ShowSQL bool          `yaml:"showSQL"`
	Mappers []string      `yaml:"mappers"`
	// contains filtered or unexported fields
}

type DBConfigBuilder 

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

func NewDBConfigBuilder 

func NewDBConfigBuilder() *DBConfigBuilder

func (*DBConfigBuilder) Build 

func (d *DBConfigBuilder) Build() *DBConfig

func (*DBConfigBuilder) DB 

func (d *DBConfigBuilder) DB(db map[string]*GoBatisDB) *DBConfigBuilder

func (*DBConfigBuilder) DS 

func (d *DBConfigBuilder) DS(dss []*DataSource) *DBConfigBuilder

func (*DBConfigBuilder) Mappers 

func (d *DBConfigBuilder) Mappers(mappers []string) *DBConfigBuilder

func (*DBConfigBuilder) ShowSQL 

func (d *DBConfigBuilder) ShowSQL(showSQL bool) *DBConfigBuilder

type DBOption 

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

func NewDBOption 

func NewDBOption() *DBOption

func NewDBOption_ 

func NewDBOption_(dbs map[string]*GoBatisDB, showSQL bool, mappers []string) *DBOption

func (*DBOption) DB 

func (ds *DBOption) DB(dbs map[string]*GoBatisDB) *DBOption

func (*DBOption) Mappers 

func (ds *DBOption) Mappers(mappers []string) *DBOption

func (*DBOption) ShowSQL 

func (ds *DBOption) ShowSQL(showSQL bool) *DBOption

func (*DBOption) ToDBConf 

func (ds *DBOption) ToDBConf() *DBConfig

func (*DBOption) Type 

func (ds *DBOption) Type() OptionType

type DBType 

type DBType string
const (
	DBTypeMySQL      DBType = "mysql"
	DBTypePostgres   DBType = "postgres"
	DBTypeClickhouse DBType = "clickhouse"
)

type DSOption 

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

func NewDSOption 

func NewDSOption() *DSOption

func NewDSOption_ 

func NewDSOption_(dss []*DataSource, showSQL bool, mappers []string) *DSOption

func (*DSOption) DS 

func (ds *DSOption) DS(dss []*DataSource) *DSOption

func (*DSOption) Mappers 

func (ds *DSOption) Mappers(mappers []string) *DSOption

func (*DSOption) ShowSQL 

func (ds *DSOption) ShowSQL(showSQL bool) *DSOption

func (*DSOption) ToDBConf 

func (ds *DSOption) ToDBConf() *DBConfig

func (*DSOption) Type 

func (ds *DSOption) Type() OptionType

type DataSource 

type DataSource struct {
	DataSource     string `yaml:"datasource"`
	DriverName     string `yaml:"driverName"`
	DataSourceName string `yaml:"dataSourceName"`
	MaxLifeTime    int    `yaml:"maxLifeTime"`
	MaxOpenConns   int    `yaml:"maxOpenConns"`
	MaxIdleConns   int    `yaml:"maxIdleConns"`
}

func NewDataSource 

func NewDataSource(dataSource string, driverName string, dataSourceName string) *DataSource

NewDataSource new data source

func NewDataSource_ 

func NewDataSource_(dataSource string, driverName string, dataSourceName string,
	maxLifeTime int, maxOpenConns int, maxIdleConns int) *DataSource

NewDataSource_ new data source

type DataSourceBuilder 

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

func NewDataSourceBuilder 

func NewDataSourceBuilder() *DataSourceBuilder

func (*DataSourceBuilder) Build 

func (d *DataSourceBuilder) Build() *DataSource

func (*DataSourceBuilder) DataSource 

func (d *DataSourceBuilder) DataSource(ds string) *DataSourceBuilder

DataSource

func (*DataSourceBuilder) DataSourceName 

func (d *DataSourceBuilder) DataSourceName(dsn string) *DataSourceBuilder

DataSourceName

func (*DataSourceBuilder) DriverName 

func (d *DataSourceBuilder) DriverName(dn string) *DataSourceBuilder

DriverName

func (*DataSourceBuilder) MaxIdleConns 

func (d *DataSourceBuilder) MaxIdleConns(mic int) *DataSourceBuilder

MaxIdleConns

func (*DataSourceBuilder) MaxLifeTime 

func (d *DataSourceBuilder) MaxLifeTime(mlt int) *DataSourceBuilder

MaxLifeTime

func (*DataSourceBuilder) MaxOpenConns 

func (d *DataSourceBuilder) MaxOpenConns(moc int) *DataSourceBuilder

MaxOpenConns

type ElemType 

type ElemType string

type FileOption 

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

func NewFileOption 

func NewFileOption(pt ...string) *FileOption

NewFileOption db config file path, default: db.yml

func (*FileOption) ToDBConf 

func (f *FileOption) ToDBConf() *DBConfig

func (*FileOption) Type 

func (f *FileOption) Type() OptionType

type GoBatis 

type GoBatis interface {
	// Select 查询数据
	Select(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)
	// SelectContext 查询数据with context
	SelectContext(ctx context.Context, stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)
	// Insert 插入数据
	Insert(stmt string, param interface{}) (lastInsertId int64, affected int64, err error)
	// InsertContext 插入数据with context
	InsertContext(ctx context.Context, stmt string, param interface{}) (lastInsertId int64, affected int64, err error)
	// Update 更新数据
	Update(stmt string, param interface{}) (affected int64, err error)
	// UpdateContext 更新数据with context
	UpdateContext(ctx context.Context, stmt string, param interface{}) (affected int64, err error)
	// Delete 刪除数据
	Delete(stmt string, param interface{}) (affected int64, err error)
	// DeleteContext 刪除数据with context
	DeleteContext(ctx context.Context, stmt string, param interface{}) (affected int64, err error)
}

type GoBatisDB 

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

func NewGoBatisDB 

func NewGoBatisDB(dbType DBType, db *sql.DB) *GoBatisDB

type ILogger 

type ILogger interface {
	SetLevel(level LogLevel)
	Info(format string, v ...interface{})
	Debug(format string, v ...interface{})
	Warn(format string, v ...interface{})
	Error(format string, v ...interface{})
	Fatal(format string, v ...interface{})
}

如果想定制logger可以实现此接口，否则日志将使用默认打印 

var LOG ILogger = defLog

type IOption 

type IOption interface {
	Type() OptionType
	ToDBConf() *DBConfig
}

type LogLevel 

type LogLevel int
const (
	LOG_LEVEL_DEBUG LogLevel = iota
	LOG_LEVEL_INFO
	LOG_LEVEL_WARN
	LOG_LEVEL_ERROR
	LOG_LEVEL_FATAL
	LOG_LEVEL_OFF
)

ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF

type NullBool 

type NullBool = sql.NullBool

func NB 

func NB(b bool) NullBool

NB to NullBool

type NullFloat64 

type NullFloat64 = sql.NullFloat64

func NF64 

func NF64(f float64) NullFloat64

NF64 to NullFloat64

type NullInt64 

type NullInt64 = sql.NullInt64

func NI64 

func NI64(i int64) NullInt64

NI64 to NullInt64

type NullString 

type NullString = sql.NullString

func NS 

func NS(s string) NullString

NS to NullString

type NullTime 

type NullTime = sql.NullTime

func NT 

func NT(t time.Time) NullTime

NT to NullTime

type OptionType 

type OptionType int
const (
	OptionTypeFile OptionType = 1
	OptionTypeDS   OptionType = 2
	OptionTypeDB   OptionType = 3
)

type OutType 

type OutType int
const (
	OutTypeFile OutType = iota
	OutTypeStd
)

type ResultType 

type ResultType string

func GetResultType 

func GetResultType(res interface{}) ResultType

type TX 

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

TX

func (*TX) Close 

func (g *TX) Close() error

Close db

ps： 

err := this.Close()

func (*TX) Delete 

func (g *TX) Delete(stmt string, param interface{}) (int64, error)

delete(stmt string, param interface{})

func (*TX) DeleteContext 

func (g *TX) DeleteContext(ctx context.Context, stmt string, param interface{}) (int64, error)

func (*TX) Insert 

func (g *TX) Insert(stmt string, param interface{}) (int64, int64, error)

insert(stmt string, param interface{})

func (*TX) InsertBatch 

func (g *TX) InsertBatch(stmt string, param interface{}) (int64, int64, error)

func (*TX) InsertContext 

func (g *TX) InsertContext(ctx context.Context, stmt string, param interface{}) (int64, int64, error)

func (*TX) Select 

func (g *TX) Select(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

reference from https://github.com/yinshuwei/osm/blob/master/osm.go end

func (*TX) SelectContext 

func (g *TX) SelectContext(ctx context.Context, stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

func (*TX) SelectV2 

func (g *TX) SelectV2(stmt string, param interface{}, rowBound ...*rowBounds) func(res interface{}) (int64, error)

func (*TX) Update 

func (g *TX) Update(stmt string, param interface{}) (int64, error)

update(stmt string, param interface{})

func (*TX) UpdateContext 

func (g *TX) UpdateContext(ctx context.Context, stmt string, param interface{}) (int64, error)

Source Files

View all Source files

Directories

Path Synopsis

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.