model

package
v0.0.0-...-1cc9653 Latest Latest
Warning

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

 Go to latest Published: Oct 21, 2021 License: GPL-3.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	In         = "IN"          // 在指定枚举值范围内
	NotIn      = "NOT IN"      // 不在指定枚举值范围内
	Between    = "BETWEEN"     // 在指定范围内
	NotBetween = "NOT BETWEEN" // 不在指定范围内
	Like       = "LIKE"        // 模糊查询like
	FindINSet  = "FIND_IN_SET" // find in set
	Raw        = "RAW"         // 原样输出
	EQ         = "="           // equal 等于<=>
	NEQ        = "<>"          // not equal 不等于(!=、<>)
	GT         = ">"           // greater than 大于
	GTE        = ">="          // greater than or equal 大于等于
	LT         = "<"           // less than 小于
	LTE        = "<"           // less than or equal 小于等于
)

定义Where条件常量便于IDE追踪

Variables

View Source 
var (
	DeptModel        Dept
	ManagerModel     Manager
	MenuModel        Menu
	RoleModel        Role
	ManagerDeptModel ManagerDept
	ManagerRoleModel ManagerRole
	ManagerOpenModel ManagerOpen
	MenuRouteModel   MenuRoute
	RoleMenuModel    RoleMenu
)

定义所有模型实例的单例，模型变量instance 

① 本质是一个结构体零值
② 因模型需要嵌入通用方法需要在init方法中调用不可导出的初始化方法进行模型初始化
③ 模型结构体会在控制器、服务类乃至helper、entry方法中调用，模型定义不可反向应用这些位置的包，否则可能导致循环引用错误

Functions

This section is empty.

Types

type BaseField 

type BaseField struct {
	ID        uint `gorm:"primaryKey"`
	CreatedAt uint `gorm:"autoCreateTime"`
	UpdatedAt uint `gorm:"autoCreateTime,autoUpdateTime"`
}

BaseField 通用基础字段

type Dept 

type Dept struct {
	Name      string `json:"name"`
	Pid       uint   `json:"pid"`
	Level     uint8  `json:"level"`
	Sort      uint   `json:"sort"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

Dept 表模型Dept表

func (*Dept) Columns 

func (m *Dept) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*Dept) CountByWhere 

func (m *Dept) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*Dept) DeleteByPrimary 

func (m *Dept) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*Dept) DeleteByWhere 

func (m *Dept) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (Dept) DeptByPid 

func (t Dept) DeptByPid(ctx context.Context, pid uint, dept *Dept) error

DeptByPid pid查询父部门

func (*Dept) FindByPrimary 

func (m *Dept) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Dept) FindByWhere 

func (m *Dept) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Dept) InsertOne 

func (m *Dept) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Dept) InsertOneUseMap 

func (m *Dept) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Dept) ListByOriginWhere 

func (m *Dept) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*Dept) ListByWhere 

func (m *Dept) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*Dept) MultiInsert 

func (m *Dept) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Dept) MultiInsertUseMap 

func (m *Dept) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Dept) Paginate 

func (m *Dept) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Dept) SimplePaginate 

func (m *Dept) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (Dept) TableName 

func (t Dept) TableName() string

TableName 返回表名称方法

func (*Dept) UpdateByWhere 

func (m *Dept) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*Dept) UpdateOne 

func (m *Dept) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type Manager 

type Manager struct {
	Name      string `json:"name"`
	Account   string `json:"account"`
	Password  string `json:"password"`
	Mobile    string `json:"mobile"`
	Email     string `json:"email"`
	IsRoot    uint8  `json:"is_root"`
	Enable    uint8  `json:"enable"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

Manager 表模型manager表

func (*Manager) Columns 

func (m *Manager) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*Manager) CountByWhere 

func (m *Manager) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*Manager) DeleteByPrimary 

func (m *Manager) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*Manager) DeleteByWhere 

func (m *Manager) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*Manager) FindByPrimary 

func (m *Manager) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Manager) FindByWhere 

func (m *Manager) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Manager) InsertOne 

func (m *Manager) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Manager) InsertOneUseMap 

func (m *Manager) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Manager) ListByOriginWhere 

func (m *Manager) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*Manager) ListByWhere 

func (m *Manager) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*Manager) MultiInsert 

func (m *Manager) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Manager) MultiInsertUseMap 

func (m *Manager) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Manager) Paginate 

func (m *Manager) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Manager) SimplePaginate 

func (m *Manager) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (Manager) TableName 

func (t Manager) TableName() string

TableName 返回表名称方法

func (*Manager) UpdateByWhere 

func (m *Manager) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*Manager) UpdateOne 

func (m *Manager) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type ManagerDept 

type ManagerDept struct {
	ManagerID uint   `json:"manager_id"`
	DeptID    uint   `json:"dept_id"`
	Sort      uint   `json:"sort"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

ManagerDept 表模型ManagerDept表

func (*ManagerDept) Columns 

func (m *ManagerDept) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*ManagerDept) CountByWhere 

func (m *ManagerDept) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*ManagerDept) DeleteByPrimary 

func (m *ManagerDept) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*ManagerDept) DeleteByWhere 

func (m *ManagerDept) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*ManagerDept) FindByPrimary 

func (m *ManagerDept) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerDept) FindByWhere 

func (m *ManagerDept) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerDept) InsertOne 

func (m *ManagerDept) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerDept) InsertOneUseMap 

func (m *ManagerDept) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerDept) ListByOriginWhere 

func (m *ManagerDept) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*ManagerDept) ListByWhere 

func (m *ManagerDept) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*ManagerDept) MultiInsert 

func (m *ManagerDept) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerDept) MultiInsertUseMap 

func (m *ManagerDept) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerDept) Paginate 

func (m *ManagerDept) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerDept) SimplePaginate 

func (m *ManagerDept) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (ManagerDept) TableName 

func (t ManagerDept) TableName() string

TableName 返回表名称方法

func (*ManagerDept) UpdateByWhere 

func (m *ManagerDept) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*ManagerDept) UpdateOne 

func (m *ManagerDept) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type ManagerOpen 

type ManagerOpen struct {
	ManagerID     uint   `json:"manager_id"`
	OpenName      string `json:"open_name"`
	OpenType      uint8  `json:"open_type"`
	OpenID        string `json:"open_id"`
	AccessToken   string `json:"access_token"`
	TokenExpireIn uint   `json:"token_expire_in"`
	RefreshToken  string `json:"refresh_token"`
	Figure        string `json:"figure"`
	UnionID       string `json:"union_id"`
	Enable        uint8  `json:"enable"`
	BaseField            // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

ManagerOpen 表模型ManagerOpen表

func (*ManagerOpen) Columns 

func (m *ManagerOpen) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*ManagerOpen) CountByWhere 

func (m *ManagerOpen) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*ManagerOpen) DeleteByPrimary 

func (m *ManagerOpen) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*ManagerOpen) DeleteByWhere 

func (m *ManagerOpen) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*ManagerOpen) FindByPrimary 

func (m *ManagerOpen) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerOpen) FindByWhere 

func (m *ManagerOpen) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerOpen) InsertOne 

func (m *ManagerOpen) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerOpen) InsertOneUseMap 

func (m *ManagerOpen) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerOpen) ListByOriginWhere 

func (m *ManagerOpen) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*ManagerOpen) ListByWhere 

func (m *ManagerOpen) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*ManagerOpen) MultiInsert 

func (m *ManagerOpen) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerOpen) MultiInsertUseMap 

func (m *ManagerOpen) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerOpen) Paginate 

func (m *ManagerOpen) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerOpen) SimplePaginate 

func (m *ManagerOpen) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (ManagerOpen) TableName 

func (t ManagerOpen) TableName() string

TableName 返回表名称方法

func (*ManagerOpen) UpdateByWhere 

func (m *ManagerOpen) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*ManagerOpen) UpdateOne 

func (m *ManagerOpen) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type ManagerRole 

type ManagerRole struct {
	ManagerID uint   `json:"manager_id"`
	RoleID    uint   `json:"role_id"`
	Sort      uint   `json:"sort"`
	Remark    string ` json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

ManagerRole 表模型ManagerRole表

func (*ManagerRole) Columns 

func (m *ManagerRole) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*ManagerRole) CountByWhere 

func (m *ManagerRole) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*ManagerRole) DeleteByPrimary 

func (m *ManagerRole) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*ManagerRole) DeleteByWhere 

func (m *ManagerRole) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*ManagerRole) FindByPrimary 

func (m *ManagerRole) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerRole) FindByWhere 

func (m *ManagerRole) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerRole) InsertOne 

func (m *ManagerRole) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerRole) InsertOneUseMap 

func (m *ManagerRole) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerRole) ListByOriginWhere 

func (m *ManagerRole) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*ManagerRole) ListByWhere 

func (m *ManagerRole) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*ManagerRole) MultiInsert 

func (m *ManagerRole) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*ManagerRole) MultiInsertUseMap 

func (m *ManagerRole) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*ManagerRole) Paginate 

func (m *ManagerRole) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*ManagerRole) SimplePaginate 

func (m *ManagerRole) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (ManagerRole) TableName 

func (t ManagerRole) TableName() string

TableName 返回表名称方法

func (*ManagerRole) UpdateByWhere 

func (m *ManagerRole) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*ManagerRole) UpdateOne 

func (m *ManagerRole) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...
type Menu struct {
	Name      string `json:"name"`
	Pid       int    `json:"pid"`
	Level     int    `json:"level"`
	Frontend  string `json:"frontend"`
	Icon      string `json:"icon"`
	Sort      int    `json:"sort"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

Menu 表模型menu表 

func (m *Menu) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
func (m *Menu) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用
func (m *Menu) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>
func (m *Menu) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片
func (m *Menu) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *Menu) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *Menu) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...
func (m *Menu) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值
func (m *Menu) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (m *Menu) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (m *Menu) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...
func (m *Menu) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值
func (m *Menu) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *Menu) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (t Menu) TableName() string

TableName 返回表名称方法 

func (m *Menu) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新
func (m *Menu) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...
type MenuRoute struct {
	MenuID    uint   `json:"menu_id"`
	Method    string `json:"method"`
	Path      string `json:"path"`
	Sort      uint   `json:"sort"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

MenuRoute 表模型MenuRoute表 

func (m *MenuRoute) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
func (m *MenuRoute) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用
func (m *MenuRoute) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>
func (m *MenuRoute) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片
func (m *MenuRoute) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *MenuRoute) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *MenuRoute) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...
func (m *MenuRoute) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值
func (m *MenuRoute) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (m *MenuRoute) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (m *MenuRoute) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...
func (m *MenuRoute) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值
func (m *MenuRoute) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (m *MenuRoute) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...
func (t MenuRoute) TableName() string

TableName 返回表名称方法 

func (m *MenuRoute) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新
func (m *MenuRoute) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type Role 

type Role struct {
	Name      string `json:"name"`
	Enable    uint   `json:"enable"`
	Sort      uint   `json:"sort"`
	Remark    string `json:"remark"`
	BaseField        // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

Role 表模型role表

func (*Role) Columns 

func (m *Role) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*Role) CountByWhere 

func (m *Role) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*Role) DeleteByPrimary 

func (m *Role) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*Role) DeleteByWhere 

func (m *Role) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*Role) FindByPrimary 

func (m *Role) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Role) FindByWhere 

func (m *Role) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Role) InsertOne 

func (m *Role) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Role) InsertOneUseMap 

func (m *Role) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Role) ListByOriginWhere 

func (m *Role) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*Role) ListByWhere 

func (m *Role) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*Role) MultiInsert 

func (m *Role) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*Role) MultiInsertUseMap 

func (m *Role) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*Role) Paginate 

func (m *Role) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*Role) SimplePaginate 

func (m *Role) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (Role) TableName 

func (t Role) TableName() string

TableName 返回表名称方法

func (*Role) UpdateByWhere 

func (m *Role) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*Role) UpdateOne 

func (m *Role) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type RoleMenu 

type RoleMenu struct {
	RoleID    uint `json:"role_id"`
	MenuID    uint `json:"menu_id"`
	BaseField      // 引入基础通用字段--主键ID、创建时间、更新时间、软删除时间(若有需要)
	// contains filtered or unexported fields
}

RoleMenu 表模型RoleMenu表

func (*RoleMenu) Columns 

func (m *RoleMenu) Columns(ctx context.Context, where []Where, target interface{}, field string, orderBy string) error

Columns 获取列数据

  • where：查询条件 Where 结构体切片
  • target：查询结果集切片引用，形参为 interface，例如: var a []uint32 \ var b []string 则传参 &a \ &b
  • fields：查询的单个字段列名称
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件

func (*RoleMenu) CountByWhere 

func (m *RoleMenu) CountByWhere(ctx context.Context, where []Where, targetTotal *int64) (err error)

CountByWhere 按where条件统计记录总数

  • 查询不到记录返回返回0
  • where：查询条件 Where 结构体切片
  • targetTotal：查询结果集总条数指针引用

func (*RoleMenu) DeleteByPrimary 

func (m *RoleMenu) DeleteByPrimary(ctx context.Context, primaryKey ...interface{}) (int64, error)

DeleteByPrimary 通过主键字段值硬删除1条或多条记录

  • 注意：model对象指定需要删除的记录的主键值 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现，本model不支持软删除 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件
  • primaryKey：数值类型的主键值，1个或多个 例子1：1 单个主键 例子2："1" 单个主键字符串类型字面量，本质是个数值 例子3：1,3,4 多个数值类型<多个需要相同类型> 例子4："1","3","4" 多个数值字符串<多个需要相同类型>

func (*RoleMenu) DeleteByWhere 

func (m *RoleMenu) DeleteByWhere(ctx context.Context, where []Where) (int64, error)

DeleteByWhere 通过model的主键字段硬删除1条记录

  • 注意：软删除功能是一项功能特性，要么全部使用gorm的软删除特性，要么业务删除时调用update方法 gorm软删除特性需在model字段定义时使用 gorm.DeletedAt 类型的字段特性实现 gorm软删除特性引入后查询条件将自动附加过滤已软删除记录的条件，无需手动指定
  • where：条件 Where 结构体切片

func (*RoleMenu) FindByPrimary 

func (m *RoleMenu) FindByPrimary(ctx context.Context, pVal interface{}, target schema.Tabler, fields ...string) (err error)

FindByPrimary 单主键查询1条记录<仅支持单字段主键不支持符合主键>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • pVal：Primary Value 需要查询的主键字段的值<仅支持数值类型主键，字符串类型不支持> 自定义模型中主键字段通过tag标签 gorm:"primaryKey" 指定的即为主键 若未定义主键，则取定义模型中的第一个字段作为主键字段使用 绝大多数情况下自增主键可使用；复合主键或字符串主键请使用 FindByWhere
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*RoleMenu) FindByWhere 

func (m *RoleMenu) FindByWhere(ctx context.Context, where []Where, target schema.Tabler, fields ...string) (err error)

FindByWhere 按where条件查询1条记录<若有多条记录符合要求取按主键升序的第一条记录>

  • 查询不到记录返回 gorm.ErrRecordNotFound 的error 使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型引用，形参为 schema.Tabler 接口类型<注意：指针也是接口类型>，需传指针
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*RoleMenu) InsertOne 

func (m *RoleMenu) InsertOne(ctx context.Context, data schema.Tabler, fields ...string) error

InsertOne 通过赋值模型创建1条记录

  • data：model实例对象，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a Ad; a.XX="yy"; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*RoleMenu) InsertOneUseMap 

func (m *RoleMenu) InsertOneUseMap(ctx context.Context, data map[string]interface{}) error

InsertOneUseMap 通过map键值对创建1条记录

  • 注意：创建成功后不会回填主键
  • data：新增1条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*RoleMenu) ListByOriginWhere 

func (m *RoleMenu) ListByOriginWhere(ctx context.Context, originWhere *gorm.DB, target interface{}, orderBy string, fields ...string) (err error)

ListByOriginWhere 按gorm原始where查询多条确认数量有限的列表记录 

 ①、可用于构造查询条件较为复杂的SQL，包括查询条件包含or、and以及使用括号连起来的分组条件
    例如：select * from tb where (id=1 OR name="tom") OR ((sex=0 OR title="leader") AND dept_id=10)
	②、特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - originWhere：gorm原始查询条件，使用gorm全局句柄构建，参考下方例子伪代码构造
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...
 例如上述列出SQL的伪代码(注意gg即为originWhere，由g1、g2组合构成)：
    g1 := client.DB.Where("id=?", 1).Or("name=?", "tom")
    g2 := client.DB.Where(client.DB.Where("sex=?", 0).Or("title=?", "leader")).Where("dept_id=?", 10)
    gg := client.DB.Where(g1).Or(g2)
    err := tbModel.ListByOriginWhere(ctx, gg, &target, "id")

func (*RoleMenu) ListByWhere 

func (m *RoleMenu) ListByWhere(ctx context.Context, where []Where, target interface{}, orderBy string, fields ...string) (err error)

ListByWhere 按where条件查询多条确认数量有限的列表记录 

	特别注意：该方法用于查询有限数量的多条记录，不设置limit条件
 - 查询不到记录返回 gorm.ErrRecordNotFound 的error
	   使用errors.Is(result.Error, gorm.ErrRecordNotFound)进行判断
 - where：查询条件 Where 结构体切片
 - target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针
    例如：var a []Ad 传参 &a
 - orderBy：排序条件字符串
    例子1：`name` <表示按name字段升序>
    例子2：`name` ASC <表示按name字段升序>
    例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序>
    例子4：给空字符串表示不设置排序条件
 - fields：查询的字段，可选不传表示默认查询出所有字段
	   可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组
	   []string{"name", "sex"}...

func (*RoleMenu) MultiInsert 

func (m *RoleMenu) MultiInsert(ctx context.Context, data interface{}, fields ...string) error

MultiInsert 通过赋值模型批量创建

  • data：model实例对象切片，请注意不要给主键字段赋值，创建成功后主键字段将填充创建记录的主键值 例如：var a []Ad; 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段创建1条新记录 []string{"name", "sex"}...

func (*RoleMenu) MultiInsertUseMap 

func (m *RoleMenu) MultiInsertUseMap(ctx context.Context, data []map[string]interface{}) error

MultiInsertUseMap 通过map键值对切片批量创建

  • 注意：创建成功后不会回填主键
  • data：批量新增多条记录的map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值

func (*RoleMenu) Paginate 

func (m *RoleMenu) Paginate(ctx context.Context, where []Where, target interface{}, targetTotal *int64, page, limit int, orderBy string, fields ...string) (err error)

Paginate 分页查询，按where条件分页查询获取分页列表数和总记录数

  • 查询不到记录返回返回0和空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • targetTotal：查询结果集总条数指针引用
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (*RoleMenu) SimplePaginate 

func (m *RoleMenu) SimplePaginate(ctx context.Context, where []Where, target interface{}, page, limit int, orderBy string, fields ...string) (err error)

SimplePaginate 简单分页查询，按where条件分页简要查询获取分页列表数据<不返回总条数减少1次查询>

  • 查询不到记录返回返回空切片
  • where：查询条件 Where 结构体切片
  • target：查询结果集模型的切片引用，形参为 interface，需要传具体model实现<schema.Tabler>的切片引用：需传指针 例如：var a []Ad 传参 &a
  • page：查询分页的当前页码数，从1开始
  • limit：查询分页的1页多少条限制
  • orderBy：排序条件字符串 例子1：`name` <表示按name字段升序> 例子2：`name` ASC <表示按name字段升序> 例子3：`name` ASC, `ID` DESC <表示按name字段升序后按ID降序> 例子4：给空字符串表示不设置排序条件
  • fields：查询的字段，可选不传表示默认查询出所有字段 可变参数查询多个字段，使用字符串切片可变参数展开模式可使用字符串切片数组 []string{"name", "sex"}...

func (RoleMenu) TableName 

func (t RoleMenu) TableName() string

TableName 返回表名称方法

func (*RoleMenu) UpdateByWhere 

func (m *RoleMenu) UpdateByWhere(ctx context.Context, where []Where, data map[string]interface{}) (int64, error)

UpdateByWhere 通过where条件更新记录

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值>
  • where：查询条件 Where 结构体切片
  • data：更新的字段map数据，注意map的键为数据库实际字段名而不是结构体FieldName，支持零值更新

func (*RoleMenu) UpdateOne 

func (m *RoleMenu) UpdateOne(ctx context.Context, data schema.Tabler, fields ...string) (int64, error)

UpdateOne 通过model的主键字段更新指定字段

  • 注意：model对象指定需要更新的单条记录的值，主键字段必须指定值 然后通过第二个可选参数指定需要更新的字段<指定的字段的零值也会被更新为对应的零值，不指定则data结构体中零值字段不会更新>
  • data：model实例对象，字段填充好需要更新的值 例如：var a Ad; a.ID=1;a.Name="Tom" 传参 &a
  • fields：限定创建语句写入的字段名<指定的字段的零值也会写入>，不传留空则取结构体非零字段去更新 []string{"name", "sex"}...

type Where 

type Where struct {
	Field string
	Op    string
	Value interface{}
}

Where 定义where查询条件 

切片Where多个条件最终SQL中将使用 AND 符拼接
- Field 查询的字段名称字符串
- Op    查询的条件符号，建议使用包内常量，全部大写[IN、NOT IN、BETWEEN、NOT BETWEEN、LIKE、FIND_IN_SET、=、<>、>=、<、<=、RAW等]
  当使用RAW时将忽略Op值，直接使用gorm提供的原生Where方法构建<注意转义特殊字符特别留意SQL注入风险>
- Value 查询的条件值，当Op为LIKE时无需添加前后的百分号<%>，方法体自动添加前后百分号

Source Files

View all Source files

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.