daox

package module
v1.0.2 Latest Latest
Warning

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

 Go to latest Published: Apr 15, 2024 License: MIT Imports: 12 Imported by: 3

README

daox

基于 sqlx + go-redis 的轻量级数据库访问辅助工具，daox 的定位是 sqlx 的功能增强，不是一个 orm。

封装了基础 crud api，实现了sqlbuilder，通过 api 生成 sql，无需手动拼接。

实现了代码生成器，有内置生成文件模板，也可以自定义模板。

安装

go get github.com/fengjx/daox

CRUD

在MySQL创建测试表

create table user_info
(
    id       bigint comment '主键',
    uid      bigint                not null,
    nickname varchar(32) default '' null comment '昵称',
    sex      tinyint     default 0 not null comment '性别',
    utime    bigint      default 0 not null comment '更新时间',
    ctime    bigint      default 0 not null comment '创建时间',
    primary key pk(id),
    unique uni_uid (uid)
) comment '用户信息表';

创建 dao 对象

db := sqlx.MustOpen("mysql", "root:1234@tcp(localhost:3306)/demo")
db.Mapper = reflectx.NewMapperFunc("json", strings.ToTitle)
dao := daox.NewDAO(db, "user_info", "id", reflect.TypeOf(&User{}), daox.IsAutoIncrement())

新增

for i := 0; i < 20; i++ {
    sec := time.Now().Unix()
    user := &User{
        Uid:      100 + int64(i),
        Nickname: randString(6),
        Sex:      int32(i) % 2,
        Utime:    sec,
        Ctime:    sec,
    }
    id, err := dao.Save(user)
    if err != nil {
        log.Panic(err)
    }
    log.Println(id)
}

查询

// id 查询
user := new(User)
err := dao.GetByID(1, user)

// 批量id查询
var list []User
err = dao.ListByIds(&list3, 10, 11)

// 指定字段查询单条记录
user := new(User)
err := dao.GetByColumn(daox.OfKv("uid", 10000), user)

// 指定字段查询多条记录
var list []*User
err := dao.List(daox.OfKv("sex", 0), &list)

// 指定字段查询多个值
var list []*User
err = dao.ListByColumns(daox.OfMultiKv("uid", 10000, 10001), &list)

修改

user := new(User)
err := dao.GetByID(10, user)
user.Nickname = "update-name-10"
// 全字段更新
ok, err := dao.Update(user)
log.Printf("update res - %v", ok)

// 部分字段更新
ok, err = dao.UpdateField(11, map[string]any{
    "nickname": "update-name-11",
})
log.Printf("update res - %v", ok)

删除

// 按 id 删除
ok, err := dao.DeleteById(21)
log.Printf("delete res - %v", ok)

user := new(User)
err = dao.GetByID(21, user)
log.Printf("delete by id res - %v", user.Id)

// 按指定字段删除
affected, err := dao.DeleteByColumn(daox.OfKv("uid", 101))
log.Printf("delete by column res - %v", affected)

// 按字段删除多条记录
affected, err = dao.DeleteByColumns(daox.OfMultiKv("uid", 102, 103))
log.Printf("multiple delete by column res - %v", affected)

sqlbuilder

创建Builder对象

// 通过dao对象实例方法创建
dao.SQLBuilder()

// 独立使用
sqlbuilder.New("user_info")

构造sql

querySQL, err := sqlbuilder.New("user_info").Select().
    Columns("id", "username", "age", "sex", "ctime").
    Where(
        sqlbuilder.C().
            Where(true, "age > ?").
            And(true, "sex = ?"),
    ).
    OrderBy(sqlbuilder.Desc("ctime")).
    Offset(10).
    Limit(10).Sql()
// SELECT `id`, `username`, `age`, `sex`, `ctime` FROM `user_info` WHERE age > ? AND sex = ? ORDER BY `ctime` DESC LIMIT 10 OFFSET 10;
log.Println(querySQL)


inserter := sqlbuilder.New("user_info").Insert().
    Columns("username", "age", "sex")

sql, err := inserter.Sql()
//  INSERT INTO `user_info`(`username`, `age`, `sex`) VALUES (?, ?, ?);
log.Println(sql)

nameSql, err := inserter.NameSql()
// INSERT INTO `user_info`(`username`, `age`, `sex`) VALUES (:username, :age, :sex);
log.Println(nameSql)


updateSQL, err := sqlbuilder.New("user_info").
    Update().
    Columns("username", "age").
        Where(sqlbuilder.C().Where(true, "id = ?")).
    Sql()
// UPDATE `user_info` SET `username` = ?, `age` = ? WHERE id = ?;
log.Println(updateSQL)


deleteSQL, err := sqlbuilder.New("user_info").Delete().
    Where(sqlbuilder.C().Where(true, "id = ?")).
    Sql()
// DELETE FROM `user_info` WHERE id = ?;
log.Println(deleteSQL)

更多示例请查看sqlbuilder/sql_test.go

代码生成

安装代码生成工具
$ go install github.com/fengjx/daox/cmd/gen@latest
$ gen -h

GLOBAL OPTIONS:
   -f value    config file path
   --help, -h  show help

生成代码

$ gen -f gen.yml

配置示例说明

ds:
  type: mysql
  dsn: root:1234@tcp(localhost:3306)/demo
target:
  custom:
    tag-name: json
    out-dir: ./out
    template-dir:
    var:
      a: aa
      b: bb
  tables:
    - user_info
参数 必须 说明
ds.type 是 数据库类型，暂时值支持 mysql
ds.dsn 是 数据库连接
target.custom.tag-name 是 model 字段的 tagName
target.custom.out-dir 是 文件生成路径
target.custom.template-dir 否 自定义模板文件路径
target.custom.var 否 自定义参数，map结构，可以在模板文件中使用
target.custom.tables 是 需要生成文件的表名，list 结构

自定义模板说明

通过text/template来渲染文件内容，模板语法不在此赘述，可自行查看参考文档。

模板中可以使用的变量，详细可以查看源码cmd/gen/gen.go

attr := map[string]any{
    "Var":     config.Target.Custom.Var,
    "TagName": config.Target.Custom.TagName,
    "Table":   table,
}

模板中可以使用的函数

  • utils.FirstUpper: 首字母大写
  • utils.FirstLower: 首字母小写
  • utils.SnakeCase: 转下划线风格字符串
  • utils.TitleCase: 转驼峰风格字符串
  • utils.GonicCase: 转go风格驼峰字符串，user_id -> userID
  • utils.LineString: 空字符串使用横线"-"代替
  • SQLType2GoTypeString: sql类型转go类型字符串
funcMap := template.FuncMap{
    "FirstUpper":           utils.FirstUpper,
    "FirstLower":           utils.FirstLower,
    "SnakeCase":            utils.SnakeCase,
    "TitleCase":            utils.TitleCase,
    "GonicCase":            utils.GonicCase,
    "LineString":           utils.LineString,
    "SQLType2GoTypeString": SQLType2GoTypeString,
}

参考_example/gen

Documentation

Index

Constants

View Source 
const (
	OpAnd Op = "and"
	OpOr  Op = "or"

	ConditionTypeEq      ConditionType = "eq"       // 等于
	ConditionTypeNotEq   ConditionType = "not_eq"   // 不等于
	ConditionTypeLike    ConditionType = "like"     // 模糊匹配
	ConditionTypeNotLike ConditionType = "not_like" // 不包含
	ConditionTypeIn      ConditionType = "in"       // in
	ConditionTypeNotIn   ConditionType = "not_in"   // not in
	ConditionTypeGt      ConditionType = "gt"       // 大于
	ConditionTypeLt      ConditionType = "lt"       // 小于
	ConditionTypeGte     ConditionType = "gte"      // 大于等于
	ConditionTypeLte     ConditionType = "lte"      // 小于等于

	OrderTypeAsc  OrderType = "asc"  // 升序
	OrderTypeDesc OrderType = "desc" // 降序
)

Variables

View Source 
var (
	ErrUpdatePrimaryKeyRequire = errors.New("[daox] Primary key require for update")
	ErrTxNil                   = errors.New("[daox] Tx is nil")
)

Functions

func Delete 

func Delete(ctx context.Context, dbx *sqlx.DB, record DeleteRecord) (int64, error)

Delete 通用 delete 操作

func Get 

func Get[T any](ctx context.Context, dbx *sqlx.DB, record GetRecord, opts ...SelectOption) (*T, error)

Get 查询单条记录

func GetMap 

func GetMap(ctx context.Context, dbx *sqlx.DB, record GetRecord, opts ...SelectOption) (map[string]any, error)

GetMap 查询单条记录，返回 map

func Insert 

func Insert(ctx context.Context, dbx *sqlx.DB, record InsertRecord, opts ...InsertOption) (int64, error)

Insert 通用 insert 操作

func Update 

func Update(ctx context.Context, dbx *sqlx.DB, record UpdateRecord, opts ...UpdateOption) (int64, error)

Update 通用 update 操作

func UseDefaultMasterDB 

func UseDefaultMasterDB(master *sqlx.DB)

func UseDefaultReadDB 

func UseDefaultReadDB(read *sqlx.DB)

Types

type Condition 

type Condition struct {
	Disable       bool          `json:"disable"`        // true 禁用该条件
	Op            Op            `json:"op"`             // and or 连接符
	Field         string        `json:"field"`          // 查询条件字段
	Vals          []any         `json:"vals"`           // 查询字段值
	ConditionType ConditionType `json:"condition_type"` // 查找类型
}

Condition 条件语句

type ConditionType 

type ConditionType string

type Dao 

type Dao struct {
	Mapper    *reflectx.Mapper
	TableMeta TableMeta
	// contains filtered or unexported fields
}

func CreateDAO 

func CreateDAO(tableName string, primaryKey string, structType reflect.Type, opts ...Option) *Dao

CreateDAO 函数用于创建一个新的Dao对象 tableName 参数表示表名 primaryKey 参数表示主键 structType 参数表示数据结构类型 opts 参数表示可选的选项 返回值为创建的Dao对象指针

func NewDAO 

func NewDAO(master *sqlx.DB, tableName string, primaryKey string, structType reflect.Type, opts ...Option) *Dao

NewDAO 函数用于创建一个新的Dao对象 master 参数用于连接数据库 tableName 参数表示表名 primaryKey 参数表示主键 structType 参数表示数据结构类型 opts 参数表示可选的选项 返回值为创建的Dao对象指针

func (*Dao) BatchReplaceInto 

func (dao *Dao) BatchReplaceInto(models any, omitColumns ...string) (int64, error)

BatchReplaceInto 批量新增，使用 replace into 方式 models 是一个 slice omitColumns 不需要 insert 的字段

func (*Dao) BatchReplaceIntoContext 

func (dao *Dao) BatchReplaceIntoContext(ctx context.Context, models any, omitColumns ...string) (int64, error)

BatchReplaceIntoContext 批量新增，使用 replace into 方式，携带上下文 models 是一个 slice omitColumns 不需要 insert 的字段

func (*Dao) BatchSave 

func (dao *Dao) BatchSave(models any, omitColumns ...string) (int64, error)

BatchSave 批量新增，携带上下文 omitColumns 不需要 insert 的字段

func (*Dao) BatchSaveContext 

func (dao *Dao) BatchSaveContext(ctx context.Context, models any, omitColumns ...string) (int64, error)

BatchSaveContext 批量新增 omitColumns 不需要 insert 的字段

func (*Dao) DBColumns 

func (dao *Dao) DBColumns(omitColumns ...string) []string

DBColumns 获取当前表数据库字段 omitColumns 表示需要忽略的字段

func (*Dao) DeleteByColumn 

func (dao *Dao) DeleteByColumn(kv *KV) (int64, error)

DeleteByColumn 按字段名删除

func (*Dao) DeleteByColumnContext 

func (dao *Dao) DeleteByColumnContext(ctx context.Context, kv *KV) (int64, error)

DeleteByColumnContext 按字段名删除，携带上下文

func (*Dao) DeleteByColumnTx 

func (dao *Dao) DeleteByColumnTx(tx *sqlx.Tx, kv *KV) (int64, error)

DeleteByColumnTx 按字段名删除，支持事务

func (*Dao) DeleteByColumnTxContext 

func (dao *Dao) DeleteByColumnTxContext(ctx context.Context, tx *sqlx.Tx, kv *KV) (int64, error)

DeleteByColumnTxContext 按字段名删除，支持事务，携带上下文

func (*Dao) DeleteByColumns 

func (dao *Dao) DeleteByColumns(kvs *MultiKV) (int64, error)

DeleteByColumns 指定字段删除多个值

func (*Dao) DeleteByColumnsContext 

func (dao *Dao) DeleteByColumnsContext(ctx context.Context, kvs *MultiKV) (int64, error)

DeleteByColumnsContext 指定字段删除多个值，携带上下文

func (*Dao) DeleteByColumnsTx 

func (dao *Dao) DeleteByColumnsTx(tx *sqlx.Tx, kvs *MultiKV) (int64, error)

DeleteByColumnsTx 指定字段多个值删除

func (*Dao) DeleteByColumnsTxContext 

func (dao *Dao) DeleteByColumnsTxContext(ctx context.Context, tx *sqlx.Tx, kvs *MultiKV) (int64, error)

DeleteByColumnsTxContext 指定字段多个值删除，携带上下文

func (*Dao) DeleteByCond 

func (dao *Dao) DeleteByCond(where sqlbuilder.ConditionBuilder) (int64, error)

DeleteByCond 根据where条件删除

func (*Dao) DeleteByCondContext 

func (dao *Dao) DeleteByCondContext(ctx context.Context, where sqlbuilder.ConditionBuilder) (int64, error)

DeleteByCondContext 根据where条件删除，携带上下文

func (*Dao) DeleteByCondTx 

func (dao *Dao) DeleteByCondTx(tx *sqlx.Tx, where sqlbuilder.ConditionBuilder) (int64, error)

DeleteByCondTx 根据where条件删除，支持事务

func (*Dao) DeleteByCondTxContext 

func (dao *Dao) DeleteByCondTxContext(ctx context.Context, tx *sqlx.Tx, where sqlbuilder.ConditionBuilder) (int64, error)

DeleteByCondTxContext 根据where条件删除，支持事务，携带上下文

func (*Dao) DeleteByID 

func (dao *Dao) DeleteByID(id any) (bool, error)

DeleteByID 根据id删除数据

func (*Dao) DeleteByIDContext 

func (dao *Dao) DeleteByIDContext(ctx context.Context, id any) (bool, error)

DeleteByIDContext 根据id删除数据，携带上下文

func (*Dao) DeleteByIDTx 

func (dao *Dao) DeleteByIDTx(tx *sqlx.Tx, id any) (bool, error)

DeleteByIDTx 根据id删除数据，支持事务

func (*Dao) DeleteByIDTxContext 

func (dao *Dao) DeleteByIDTxContext(ctx context.Context, tx *sqlx.Tx, id any) (bool, error)

DeleteByIDTxContext 根据id删除数据，支持事务，携带上下文

func (*Dao) Get 

func (dao *Dao) Get(dest any, selector *sqlbuilder.Selector) (bool, error)

Get 根据查询条件查询单条记录 dest 必须是一个指针

func (*Dao) GetByColumn 

func (dao *Dao) GetByColumn(kv *KV, dest Model) (bool, error)

GetByColumn 按指定字段查询单条数据 bool 数据是否存在

func (*Dao) GetByColumnContext 

func (dao *Dao) GetByColumnContext(ctx context.Context, kv *KV, dest Model) (bool, error)

GetByColumnContext 按指定字段查询单条数据，携带上下文 bool 数据是否存在

func (*Dao) GetByColumnTx 

func (dao *Dao) GetByColumnTx(tx *sqlx.Tx, kv *KV, dest Model) (bool, error)

GetByColumnTx 按指定字段查询单条数据，支持事务 bool 数据是否存在

func (*Dao) GetByColumnTxContext 

func (dao *Dao) GetByColumnTxContext(ctx context.Context, tx *sqlx.Tx, kv *KV, dest Model) (bool, error)

GetByColumnTxContext 按指定字段查询单条数据，支持事务，携带上下文 bool 数据是否存在

func (*Dao) GetByID 

func (dao *Dao) GetByID(id any, dest Model) (bool, error)

GetByID 根据 id 查询单条数据

func (*Dao) GetByIDContext 

func (dao *Dao) GetByIDContext(ctx context.Context, id any, dest Model) (bool, error)

GetByIDContext 根据 id 查询单条数据，携带上下文

func (*Dao) GetColumnsByModel 

func (dao *Dao) GetColumnsByModel(model any, omitColumns ...string) []string

GetColumnsByModel 根据 model 结构获取数据库字段 omitColumns 表示需要忽略的字段

func (*Dao) GetColumnsByType 

func (dao *Dao) GetColumnsByType(typ reflect.Type, omitColumns ...string) []string

GetColumnsByType 通过字段 tag 解析数据库字段

func (*Dao) GetContext 

func (dao *Dao) GetContext(ctx context.Context, dest any, selector *sqlbuilder.Selector) (bool, error)

func (*Dao) GetMasterDB 

func (dao *Dao) GetMasterDB() *sqlx.DB

func (*Dao) GetReadDB 

func (dao *Dao) GetReadDB() *sqlx.DB

func (*Dao) GetTx 

func (dao *Dao) GetTx(tx *sqlx.Tx, dest any, selector *sqlbuilder.Selector) (bool, error)

GetTx 根据查询条件查询单条记录，支持事务 dest 必须是一个指针

func (*Dao) GetTxContext 

func (dao *Dao) GetTxContext(ctx context.Context, tx *sqlx.Tx, dest any, selector *sqlbuilder.Selector) (bool, error)

GetTxContext 根据查询条件查询单条记录，支持事务，携带上下文 dest 必须是一个指针

func (*Dao) IgnoreInto 

func (dao *Dao) IgnoreInto(dest Model, omitColumns ...string) (int64, error)

IgnoreInto 使用 INSERT IGNORE INTO 如果记录已存在则忽略 omitColumns 不需要 insert 的字段

func (*Dao) IgnoreIntoContext 

func (dao *Dao) IgnoreIntoContext(ctx context.Context, dest Model, omitColumns ...string) (int64, error)

IgnoreIntoContext 使用 INSERT IGNORE INTO 如果记录已存在则忽略，携带上下文 omitColumns 不需要 insert 的字段

func (*Dao) List 

func (dao *Dao) List(kv *KV, dest any) error

List 指定字段查询多条数据

func (*Dao) ListByColumns 

func (dao *Dao) ListByColumns(kvs *MultiKV, dest any) error

ListByColumns 指定字段多个值查询多条数据 dest: slice pointer

func (*Dao) ListByColumnsContext 

func (dao *Dao) ListByColumnsContext(ctx context.Context, kvs *MultiKV, dest any) error

ListByColumnsContext 指定字段多个值查询多条数据，携带上下文 dest: slice pointer

func (*Dao) ListByColumnsTx 

func (dao *Dao) ListByColumnsTx(tx *sqlx.Tx, kvs *MultiKV, dest any) error

ListByColumnsTx 指定字段多个值查询多条数据，支持事务

func (*Dao) ListByColumnsTxContext 

func (dao *Dao) ListByColumnsTxContext(ctx context.Context, tx *sqlx.Tx, kvs *MultiKV, dest any) error

ListByColumnsTxContext 指定字段多个值查询多条数据，支持事务，携带上下文

func (*Dao) ListByIDs 

func (dao *Dao) ListByIDs(dest any, ids ...any) error

ListByIDs 根据 id 查询多条数据

func (*Dao) ListByIDsContext 

func (dao *Dao) ListByIDsContext(ctx context.Context, dest any, ids ...any) error

ListByIDsContext 根据 id 查询多条数据，携带上下文

func (*Dao) ListByIDsTx 

func (dao *Dao) ListByIDsTx(tx *sqlx.Tx, dest any, ids ...any) error

ListByIDsTx 查询多个id值，支持事务

func (*Dao) ListByIDsTxContext 

func (dao *Dao) ListByIDsTxContext(ctx context.Context, tx *sqlx.Tx, dest any, ids ...any) error

ListByIDsTxContext 查询多个id值，支持事务，携带上下文

func (*Dao) ListContext 

func (dao *Dao) ListContext(ctx context.Context, kv *KV, dest any) error

ListContext 指定字段查询多条数据，携带上下文

func (*Dao) ListTx 

func (dao *Dao) ListTx(tx *sqlx.Tx, kv *KV, dest any) error

ListTx 指定字段查询多条数据，支持事务

func (*Dao) ListTxContext 

func (dao *Dao) ListTxContext(ctx context.Context, tx *sqlx.Tx, kv *KV, dest any) error

ListTxContext 指定字段查询多条数据，支持事务，携带上下文

func (*Dao) ReplaceInto 

func (dao *Dao) ReplaceInto(dest Model, omitColumns ...string) (int64, error)

ReplaceInto replace into table omitColumns 不需要 insert 的字段

func (*Dao) ReplaceIntoContext 

func (dao *Dao) ReplaceIntoContext(ctx context.Context, dest Model, omitColumns ...string) (int64, error)

ReplaceIntoContext replace into table，携带上下文 omitColumns 不需要 insert 的字段

func (*Dao) SQLBuilder 

func (dao *Dao) SQLBuilder() *sqlbuilder.Builder

SQLBuilder 创建当前表的 sqlbuilder

func (*Dao) Save 

func (dao *Dao) Save(dest Model, omitColumns ...string) (int64, error)

Save 插入数据 omitColumns 不需要 insert 的字段

func (*Dao) SaveContext 

func (dao *Dao) SaveContext(ctx context.Context, dest Model, omitColumns ...string) (int64, error)

SaveContext 插入数据，携带上下文 omitColumns 不需要 insert 的字段

func (*Dao) SaveTx 

func (dao *Dao) SaveTx(tx *sqlx.Tx, dest Model, omitColumns ...string) (int64, error)

SaveTx 插入数据，支持事务 omitColumns 不需要 insert 的字段

func (*Dao) SaveTxContext 

func (dao *Dao) SaveTxContext(ctx context.Context, tx *sqlx.Tx, dest Model, omitColumns ...string) (int64, error)

SaveTxContext 插入数据，支持事务，携带上下文 omitColumns 不需要 insert 的字段

func (*Dao) Select 

func (dao *Dao) Select(dest any, selector *sqlbuilder.Selector) error

Select 根据查询条件查询列表 dest 必须是一个 slice 指针

func (*Dao) SelectContext 

func (dao *Dao) SelectContext(ctx context.Context, dest any, selector *sqlbuilder.Selector) error

SelectContext 根据查询条件查询列表，携带上下文 dest 必须是一个 slice 指针

func (*Dao) SelectTx 

func (dao *Dao) SelectTx(tx *sqlx.Tx, dest any, selector *sqlbuilder.Selector) error

SelectTx 根据查询条件查询列表 dest 必须是一个 slice 指针

func (*Dao) SelectTxContext 

func (dao *Dao) SelectTxContext(ctx context.Context, tx *sqlx.Tx, dest any, selector *sqlbuilder.Selector) error

SelectTxContext 根据查询条件查询列表，携带上下文 dest 必须是一个 slice 指针

func (*Dao) Selector 

func (dao *Dao) Selector(columns ...string) *sqlbuilder.Selector

Selector 创建当前表的 selector columns 是查询指定字段，为空则是全部字段

func (*Dao) TableName 

func (dao *Dao) TableName() string

TableName 获取当前表名

func (*Dao) Update 

func (dao *Dao) Update(m Model, omitColumns ...string) (bool, error)

Update 全字段更新

func (*Dao) UpdateByCond 

func (dao *Dao) UpdateByCond(attr map[string]any, where sqlbuilder.ConditionBuilder) (int64, error)

UpdateByCond 根据条件更新字段 attr 字段更新值

func (*Dao) UpdateByCondContext 

func (dao *Dao) UpdateByCondContext(ctx context.Context, attr map[string]any, where sqlbuilder.ConditionBuilder) (int64, error)

UpdateByCondContext 根据条件更新字段，携带上下文 attr 字段更新值

func (*Dao) UpdateByCondTx 

func (dao *Dao) UpdateByCondTx(tx *sqlx.Tx, attr map[string]any, where sqlbuilder.ConditionBuilder) (int64, error)

UpdateByCondTx 根据条件更新字段，支持事务

func (*Dao) UpdateByCondTxContext 

func (dao *Dao) UpdateByCondTxContext(ctx context.Context, tx *sqlx.Tx, attr map[string]any, where sqlbuilder.ConditionBuilder) (int64, error)

UpdateByCondTxContext 根据条件更新字段，支持事务，携带上下文

func (*Dao) UpdateContext 

func (dao *Dao) UpdateContext(ctx context.Context, m Model, omitColumns ...string) (bool, error)

UpdateContext 全字段更新，携带上下文

func (*Dao) UpdateField 

func (dao *Dao) UpdateField(idValue any, fieldMap map[string]any) (bool, error)

UpdateField 部分字段更新

func (*Dao) UpdateFieldContext 

func (dao *Dao) UpdateFieldContext(ctx context.Context, idValue any, fieldMap map[string]any) (bool, error)

UpdateFieldContext 部分字段更新，携带上下文

func (*Dao) UpdateFieldTx 

func (dao *Dao) UpdateFieldTx(tx *sqlx.Tx, idValue any, fieldMap map[string]any) (bool, error)

UpdateFieldTx 部分字段更新，支持事务

func (*Dao) UpdateFieldTxContext 

func (dao *Dao) UpdateFieldTxContext(ctx context.Context, tx *sqlx.Tx, idValue any, fieldMap map[string]any) (bool, error)

UpdateFieldTxContext 部分字段更新，支持事务，携带上下文

func (*Dao) UpdateTx 

func (dao *Dao) UpdateTx(tx *sqlx.Tx, m Model, omitColumns ...string) (bool, error)

UpdateTx 全字段更新，支持事务

func (*Dao) UpdateTxContext 

func (dao *Dao) UpdateTxContext(ctx context.Context, tx *sqlx.Tx, m Model, omitColumns ...string) (bool, error)

UpdateTxContext 全字段更新，支持事务，携带上下文

func (*Dao) With 

func (dao *Dao) With(master, read *sqlx.DB, opts ...Option) *Dao

With 使用新的数据库连接创建 Dao

type DataWrapper 

type DataWrapper[S any, T any] func(context.Context, S) T

type DeleteRecord 

type DeleteRecord struct {
	TableName  string      `json:"table_name"` // 表名
	Conditions []Condition `json:"conditions"` // 条件字段
}

DeleteRecord 删除记录

type FieldsFilter 

type FieldsFilter func(context.Context) []string

type GetRecord 

type GetRecord struct {
	TableName  string      `json:"table_name"`           // 查询表
	Fields     []string    `json:"fields"`               // 投影字段
	Conditions []Condition `json:"conditions,omitempty"` // 查找字段
}

GetRecord 单条记录查询

func (GetRecord) ToSQLArgs 

func (r GetRecord) ToSQLArgs() (sql string, args []any, err error)

ToSQLArgs 返回 sql 语句和参数

type InsertOption 

type InsertOption func(*InsertOptions)

func WithInsertDataWrapper 

func WithInsertDataWrapper(dataWrapper DataWrapper[map[string]any, map[string]any]) InsertOption

WithInsertDataWrapper 数据转换

func WithInsertFieldsFilter 

func WithInsertFieldsFilter(fieldsFilter FieldsFilter) InsertOption

WithInsertFieldsFilter 过滤 insert 字段

type InsertOptions 

type InsertOptions struct {
	DataWrapper  DataWrapper[map[string]any, map[string]any]
	FieldsFilter FieldsFilter
}

type InsertRecord 

type InsertRecord struct {
	TableName string         `json:"table_name"` // 表名
	Row       map[string]any `json:"row"`        // 行数据
}

InsertRecord 插入记录

type KV 

type KV struct {
	Key   string
	Value any
}

func OfKv 

func OfKv(key string, value any) *KV

type Model 

type Model interface {
	GetID() any
}

type MultiKV 

type MultiKV struct {
	Key    string
	Values []any
}

func OfMultiKv 

func OfMultiKv(key string, values ...any) *MultiKV

func (*MultiKV) AddValue 

func (kv *MultiKV) AddValue(val string) *MultiKV

type Op 

type Op string

Op and or连接符

type Option 

type Option func(*Dao)

func IsAutoIncrement 

func IsAutoIncrement() Option

IsAutoIncrement 是否自增主键

func WithDBMaster 

func WithDBMaster(master *sqlx.DB) Option

WithDBMaster 设置主库

func WithDBRead 

func WithDBRead(read *sqlx.DB) Option

WithDBRead 设置从库

func WithMapper 

func WithMapper(Mapper *reflectx.Mapper) Option

func WithTableName 

func WithTableName(tableName string) Option

type OrderField 

type OrderField struct {
	Field     string    `json:"field"`
	OrderType OrderType `json:"order_type"`
}

OrderField 排序字段

type OrderType 

type OrderType string

type Page 

type Page struct {
	Offset     int64 `json:"offset"`      // 游标起始位置
	Limit      int64 `json:"limit"`       // 每页记录数
	HasNext    bool  `json:"has_next"`    // 是否有下一页
	Count      int64 `json:"count"`       // 总记录数
	QueryCount bool  `json:"query_count"` // 是否查询总数
}

Page 分页参数

func Find 

func Find[T any](ctx context.Context, dbx *sqlx.DB, query QueryRecord, opts ...SelectOption) (list []T, page *Page, err error)

Find 通用查询封装

func FindListMap 

func FindListMap(ctx context.Context, dbx *sqlx.DB, query QueryRecord, opts ...SelectOption) (list []map[string]any, page *Page, err error)

FindListMap 通用查询封装，返回 map 类型

type QueryRecord 

type QueryRecord struct {
	TableName   string       `json:"table_name"`             // 查询表
	Fields      []string     `json:"fields"`                 // 投影字段
	Conditions  []Condition  `json:"conditions,omitempty"`   // 查找字段
	OrderFields []OrderField `json:"order_fields,omitempty"` // 排序字段
	Page        *Page        `json:"page,omitempty"`         // 分页参数
}

QueryRecord 查询参数

func (QueryRecord) ToCountSQLArgs 

func (q QueryRecord) ToCountSQLArgs() (sql string, args []any, err error)

ToCountSQLArgs 返回 count 查询 sql 语句和参数

func (QueryRecord) ToSQLArgs 

func (q QueryRecord) ToSQLArgs() (sql string, args []any, err error)

ToSQLArgs 返回 sql 语句和参数

type SelectOption 

type SelectOption func(*SelectOptions)

func WithSelectDataWrapper 

func WithSelectDataWrapper(resultWrapper DataWrapper[any, any]) SelectOption

WithSelectDataWrapper 返回结果转换

func WithSelectFieldsFilter 

func WithSelectFieldsFilter(fieldsFilter FieldsFilter) SelectOption

WithSelectFieldsFilter 过滤 select 字段

type SelectOptions 

type SelectOptions struct {
	FieldsFilter  FieldsFilter
	ResultWrapper DataWrapper[any, any]
}

type TableMeta 

type TableMeta struct {
	TableName       string
	StructType      reflect.Type
	Columns         []string
	PrimaryKey      string
	IsAutoIncrement bool
}

func GetMeta 

func GetMeta(tableName string) (meta TableMeta, ok bool)

GetMeta 根据表名获得元信息

func (*TableMeta) OmitColumns 

func (meta *TableMeta) OmitColumns(omit ...string) []string

OmitColumns 数据库表字段 omit 包含的字段

type TxFun 

type TxFun func(txCtx context.Context, tx *sqlx.Tx) error

TxFun 事务处理函数

type TxManager 

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

TxManager 事务管理器

func NewTxManager 

func NewTxManager(db *sqlx.DB) *TxManager

NewTxManager 创建事务管理器

func (*TxManager) ExecTx 

func (m *TxManager) ExecTx(ctx context.Context, fn TxFun) (err error)

ExecTx 事务处理

type UpdateOption 

type UpdateOption func(*UpdateOptions)

func WithUpdateDataWrapper 

func WithUpdateDataWrapper(dataWrapper DataWrapper[map[string]any, map[string]any]) UpdateOption

WithUpdateDataWrapper 数据转换

func WithUpdateFieldsFilter 

func WithUpdateFieldsFilter(fieldsFilter FieldsFilter) UpdateOption

WithUpdateFieldsFilter 过滤 update 字段

type UpdateOptions 

type UpdateOptions struct {
	DataWrapper  DataWrapper[map[string]any, map[string]any]
	FieldsFilter FieldsFilter
}

type UpdateRecord 

type UpdateRecord struct {
	TableName  string         `json:"table_name"` // 表名
	Row        map[string]any `json:"row"`        // 要修改的行记录
	Conditions []Condition    `json:"conditions"` // 条件字段
}

UpdateRecord 更新记录

Source Files

View all Source files

Directories

Path Synopsis
cmd
gen
ql

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.