daox

package module
v1.1.0-rc06 Latest Latest
Warning

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

 Go to latest Published: Jul 28, 2024 License: MIT Imports: 14 Imported by: 6

README

daox

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

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

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

安装

go get github.com/fengjx/daox

文档&示例

GoDoc

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
db := sqlx.MustOpen("mysql", "root:1234@tcp(localhost:3306)/demo")
db.Mapper = reflectx.NewMapperFunc("json", strings.ToTitle)
// 注册全局DB
daox.UseDefaultMasterDB(db)
dao := daox.NewDao[*User](tableName, "id", daox.IsAutoIncrement())

// 使用 NewDao 创建
db := sqlx.MustOpen("mysql", "root:1234@tcp(localhost:3306)/demo")
db.Mapper = reflectx.NewMapperFunc("json", strings.ToTitle)
dao := daox.NewDao[*User](tableName, "id", daox.IsAutoIncrement(), daox.WithDBMaster(db))

// 使用 meta 接口创建
db := sqlx.MustOpen("mysql", "root:1234@tcp(localhost:3306)/demo")
db.Mapper = reflectx.NewMapperFunc("json", strings.ToTitle)
dao := daox.NewDaoByMeta(UserMeta)

新增

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:
        module: sys
      blog:
        module: core
参数 必须 说明
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) (*T, error)

Get 查询单条记录

func GetMap 

func GetMap(ctx context.Context, dbx *sqlx.DB, record GetRecord) (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) (int64, error)

Update 通用 update 操作

func UseDefaultMasterDB 

func UseDefaultMasterDB(master *sqlx.DB, middlewares ...engine.Middleware)

UseDefaultMasterDB 默认主库

func UseDefaultReadDB 

func UseDefaultReadDB(read *sqlx.DB, middlewares ...engine.Middleware)

UseDefaultReadDB 默认从库

func UseSaveOmits 

func UseSaveOmits(omits ...string)

UseSaveOmits 设置保存时全局默认忽略的字段

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 DB 

type DB struct {
	*sqlx.DB
	// contains filtered or unexported fields
}

DB 包装 sqlx.DB

func NewDb 

func NewDb(db *sqlx.DB, middlewares ...engine.Middleware) *DB

NewDb 创建 DB

func (*DB) Beginx 

func (d *DB) Beginx() (*Tx, error)

Beginx 打开一个事务

func (*DB) ExecContext 

func (d *DB) ExecContext(ctx context.Context, execSQL string, args ...any) (sql.Result, error)

ExecContext 使用数组参数执行sql

func (*DB) GetContext 

func (d *DB) GetContext(ctx context.Context, dest any, query string, args ...any) error

GetContext 查询单条数据

func (*DB) NamedExecContext 

func (d *DB) NamedExecContext(ctx context.Context, execSQL string, arg any) (sql.Result, error)

NamedExecContext 使用命名参数执行sql

func (*DB) SelectContext 

func (d *DB) SelectContext(ctx context.Context, dest any, query string, args ...any) error

SelectContext 查询多条数据

type Dao 

type Dao struct {
	TableMeta TableMeta
	// contains filtered or unexported fields
}

Dao 数据访问

func NewDao 

func NewDao[T Model](tableName string, primaryKey string, opts ...Option) *Dao

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

func NewDaoByMeta 

func NewDaoByMeta(m Meta, opts ...Option) *Dao

NewDaoByMeta 根据 meta 接口创建 dao 对象

func (*Dao) BatchReplaceInto 

func (d *Dao) BatchReplaceInto(models any, opts ...InsertOption) (int64, error)

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

func (*Dao) BatchReplaceIntoContext 

func (d *Dao) BatchReplaceIntoContext(ctx context.Context, models any, opts ...InsertOption) (int64, error)

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

func (*Dao) BatchSave 

func (d *Dao) BatchSave(models any, opts ...InsertOption) (int64, error)

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

func (*Dao) BatchSaveContext 

func (d *Dao) BatchSaveContext(ctx context.Context, models any, opts ...InsertOption) (int64, error)

BatchSaveContext 批量新增 omitColumns 不需要 insert 的字段 models 是一个批量 insert 的 slice

func (*Dao) DBColumns 

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

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

func (*Dao) DeleteByColumn 

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

DeleteByColumn 按字段名删除

func (*Dao) DeleteByColumnContext 

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

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

func (*Dao) DeleteByColumnTx 

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

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

func (*Dao) DeleteByColumnTxContext 

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

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

func (*Dao) DeleteByColumns 

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

DeleteByColumns 指定字段删除多个值

func (*Dao) DeleteByColumnsContext 

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

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

func (*Dao) DeleteByColumnsTx 

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

DeleteByColumnsTx 指定字段多个值删除

func (*Dao) DeleteByColumnsTxContext 

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

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

func (*Dao) DeleteByID 

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

DeleteByID 根据id删除数据

func (*Dao) DeleteByIDContext 

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

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

func (*Dao) DeleteByIDTx 

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

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

func (*Dao) DeleteByIDTxContext 

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

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

func (*Dao) Deleter 

func (d *Dao) Deleter() *sqlbuilder.Deleter

Deleter 创建当前表的 Deleter

func (*Dao) GetByColumn 

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

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

func (*Dao) GetByColumnContext 

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

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

func (*Dao) GetByColumnTx 

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

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

func (*Dao) GetByColumnTxContext 

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

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

func (*Dao) GetByID 

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

GetByID 根据 id 查询单条数据

func (*Dao) GetByIDContext 

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

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

func (*Dao) GetColumnsByModel 

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

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

func (*Dao) GetColumnsByType 

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

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

func (*Dao) IgnoreInto 

func (d *Dao) IgnoreInto(model Model, opts ...InsertOption) (int64, error)

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

func (*Dao) IgnoreIntoContext 

func (d *Dao) IgnoreIntoContext(ctx context.Context, model Model, opts ...InsertOption) (int64, error)

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

func (*Dao) Inserter 

func (d *Dao) Inserter() *sqlbuilder.Inserter

Inserter 创建当前表的 updater

func (*Dao) List 

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

List 指定字段查询多条数据

func (*Dao) ListByColumns 

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

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

func (*Dao) ListByColumnsContext 

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

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

func (*Dao) ListByColumnsTx 

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

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

func (*Dao) ListByColumnsTxContext 

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

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

func (*Dao) ListByIDs 

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

ListByIDs 根据 id 查询多条数据

func (*Dao) ListByIDsContext 

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

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

func (*Dao) ListByIDsTx 

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

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

func (*Dao) ListByIDsTxContext 

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

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

func (*Dao) ListContext 

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

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

func (*Dao) ListTx 

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

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

func (*Dao) ListTxContext 

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

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

func (*Dao) ReplaceInto 

func (d *Dao) ReplaceInto(dest Model, opts ...InsertOption) (int64, error)

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

func (*Dao) ReplaceIntoContext 

func (d *Dao) ReplaceIntoContext(ctx context.Context, model Model, opts ...InsertOption) (int64, error)

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

func (*Dao) SQLBuilder 

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

SQLBuilder 创建当前表的 sqlbuilder

func (*Dao) Save 

func (d *Dao) Save(dest Model, opts ...InsertOption) (int64, error)

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

func (*Dao) SaveContext 

func (d *Dao) SaveContext(ctx context.Context, dest Model, opts ...InsertOption) (int64, error)

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

func (*Dao) SaveTx 

func (d *Dao) SaveTx(tx *sqlx.Tx, dest Model, opts ...InsertOption) (int64, error)

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

func (*Dao) SaveTxContext 

func (d *Dao) SaveTxContext(ctx context.Context, tx *sqlx.Tx, dest Model, opts ...InsertOption) (int64, error)

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

func (*Dao) Selector 

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

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

func (*Dao) TableName 

func (d *Dao) TableName() string

TableName 获取当前表名

func (*Dao) Update 

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

Update 全字段更新

func (*Dao) UpdateContext 

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

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

func (*Dao) UpdateField 

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

UpdateField 部分字段更新

func (*Dao) UpdateFieldContext 

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

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

func (*Dao) UpdateFieldTx 

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

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

func (*Dao) UpdateFieldTxContext 

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

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

func (*Dao) UpdateTx 

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

UpdateTx 全字段更新，支持事务

func (*Dao) UpdateTxContext 

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

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

func (*Dao) Updater 

func (d *Dao) Updater() *sqlbuilder.Updater

Updater 创建当前表的 Updater

func (*Dao) With 

func (d *Dao) With(master, read *sqlx.DB) *Dao

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

func (*Dao) WithTableName 

func (d *Dao) WithTableName(tableName string) *Dao

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

type DeleteRecord 

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

DeleteRecord 删除记录

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 DisableGlobalInsertOmits 

func DisableGlobalInsertOmits(disable bool) InsertOption

DisableGlobalInsertOmits insert 数据时，禁用全局忽略字段

func WithInsertOmits 

func WithInsertOmits(omits ...string) InsertOption

WithInsertOmits 当前 insert 时，忽略的字段

type InsertOptions 

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

InsertOptions insert 选项

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 Meta 

type Meta interface {
	TableName() string
	PrimaryKey() string
	IsAutoIncrement() bool
	Columns() []string
}

Meta 数据库表元信息定义接口

type Model 

type Model interface {
	GetID() any
}

Model 数据库 model 定义

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(*Options)

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 WithIfNullVal 

func WithIfNullVal(col string, val string) Option

WithIfNullVal 设置字段为null时的默认值

func WithIfNullVals 

func WithIfNullVals(vals map[string]string) Option

WithIfNullVals 设置字段（多个）为null时的默认值

func WithMapper 

func WithMapper(mapper *reflectx.Mapper) Option

WithMapper 设置字段映射

func WithMiddleware 

func WithMiddleware(middlewares ...engine.Middleware) Option

WithMiddleware 设置中间件

func WithOmitColumns 

func WithOmitColumns(omitColumns ...string) Option

WithOmitColumns 设置忽略字段

func WithTableName 

func WithTableName(tableName string) Option

WithTableName 设置表名

type Options 

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

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) (list []T, page *Page, err error)

Find 通用查询封装

func FindListMap 

func FindListMap(ctx context.Context, dbx *sqlx.DB, query QueryRecord) (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 TableMeta 

type TableMeta struct {
	TableName       string
	Columns         []string
	PrimaryKey      string
	IsAutoIncrement bool
}

TableMeta 数据库表元信息

func GetMetaInfo 

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

GetMetaInfo 根据表名获得元信息

func (TableMeta) OmitColumns 

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

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

func (TableMeta) WithTableName 

func (meta TableMeta) WithTableName(tableName string) TableMeta

WithTableName 设置表名，一般用在分表的场景，设置实际物理表名

type Tx 

type Tx struct {
	*sqlx.Tx
	// contains filtered or unexported fields
}

func (*Tx) ExecContext 

func (t *Tx) ExecContext(ctx context.Context, execSQL string, args ...any) (sql.Result, error)

ExecContext 使用数组参数执行sql

func (*Tx) GetContext 

func (t *Tx) GetContext(ctx context.Context, dest any, query string, args ...any) error

GetContext 查询单条数据

func (*Tx) NamedExecContext 

func (t *Tx) NamedExecContext(ctx context.Context, execSQL string, arg any) (sql.Result, error)

NamedExecContext 使用命名参数执行sql

func (*Tx) SelectContext 

func (t *Tx) SelectContext(ctx context.Context, dest any, query string, args ...any) error

SelectContext 查询多条数据

type TxFun 

type TxFun func(txCtx context.Context, executor engine.Executor) 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 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.