db类

package
v0.0.0-...-7e18bce Latest Latest
Warning

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

 Go to latest Published: Sep 4, 2024 License: MIT Imports: 47 Imported by: 0

Documentation

Overview

包gdb为流行的关系型数据库提供ORM（对象关系映射）功能。

待办事项：将context.Context作为所有数据库操作的必需参数。 md5:ed61b69bd00b7384

Index

Constants

View Source 
const (
	InsertOperationInsert      = "INSERT"
	InsertOperationReplace     = "REPLACE"
	InsertOperationIgnore      = "INSERT IGNORE"
	InsertOnDuplicateKeyUpdate = "ON DUPLICATE KEY UPDATE"
)
View Source 
const (
	OrmTagForStruct    = "orm"
	OrmTagForTable     = "table"
	OrmTagForWith      = "with"
	OrmTagForWithWhere = "where"
	OrmTagForWithOrder = "order"
	OrmTagForDo        = "do"
)
View Source 
const (
	DefaultGroupName = "default" // Default group name.
)

Variables

This section is empty.

Functions

func FormatMultiLineSqlToSingle 

func FormatMultiLineSqlToSingle(sql string) (string, error)

FormatMultiLineSqlToSingle 将多行SQL模板字符串格式化为单行。 md5:cb1180487fd5c495

func X取结构体数组或Map数组值 

func X取结构体数组或Map数组值(结构体数组或Map数组 interface{}, 名称 interface{}, 子名称 ...interface{}) (数组值 []interface{})

X取结构体数组或Map数组值 从所有具有键为 `key` 的映射或结构体元素中检索并返回。请注意，参数 `list` 应该是包含映射或结构体元素的切片，否则将返回一个空切片。

参数 `list` 支持以下类型： []map[string]interface{} []map[string]子映射 []struct []struct:子结构体 如果提供了可选参数 `subKey`，子映射/子结构体才有意义。请参阅 gutil.X取结构体数组或Map数组值。 md5:e67327bcbcd82096

func X取结构体数组或Map数组值并去重 

func X取结构体数组或Map数组值并去重(结构体数组或Map数组 interface{}, 名称 string, 子名称 ...interface{}) []interface{}

X取结构体数组或Map数组值并去重 获取并返回所有结构体/映射中键为`key`的唯一元素。 注意，参数`list`应为切片类型，且包含的元素为映射或结构体， 否则将返回一个空切片。 参见gutil.X取结构体数组或Map数组值并去重。 md5:aa00cb15fafa41ba

func X底层GetInsertOperationByOption 

func X底层GetInsertOperationByOption(选项 InsertOption) string

X底层GetInsertOperationByOption 根据给定的 `option` 参数返回合适的插入操作选项。 md5:19b87dd1244d55ec

func X底层GetPrimaryKeyCondition 

func X底层GetPrimaryKeyCondition(primary string, where ...interface{}) (newWhereCondition []interface{})

X底层GetPrimaryKeyCondition 通过主键字段名返回一个新的WHERE条件。可选参数`where`的格式如下： 123 => primary=123 []int{1, 2, 3} => primary IN(1,2,3) "john" => primary='john' []string{"john", "smith"} => primary IN('john','smith') g.Map{"id": g.Slice{1,2,3}} => id IN(1,2,3) g.Map{"id": 1, "name": "john"} => id=1 AND name='john' 等等。

注意，如果主键为空或者`where`参数长度大于1，它会直接返回给定的`where`参数。 md5:748dfa9c0f0d93b5

func X底层WithDB 

func X底层WithDB(上下文 context.Context, DB对象 DB) context.Context

X底层WithDB 将给定的db对象注入到context中并返回一个新的context。 md5:e414408e96157a02

func X底层WithTX 

func X底层WithTX(上下文 context.Context, 事务对象 TX) context.Context

X底层WithTX 将给定的事务对象注入到上下文中，并返回一个新的上下文。 md5:b4c3c1077b95f681

func X捕捉SQL语句 

func X捕捉SQL语句(上下文 context.Context, 回调函数 func(上下文 context.Context) error) (sql数组 []string, 错误 error)

X捕捉SQL语句捕获并返回在给定闭包函数中执行的所有SQL语句。 注意，所有以下SQL语句都应使用由`f`函数传递的context对象。 md5:1088111f1248173d

func X捕捉最后一条SQL语句 

func X捕捉最后一条SQL语句(上下文 context.Context, 回调函数 func(上下文 context.Context) error) (sql string, 错误 error)

X捕捉最后一条SQL语句 将给定闭包函数中的最后一个 SQL 语句格式化并返回，但并不会真正执行。 注意，所有后续的 SQL 语句都应该使用由函数 `f` 传递的上下文对象。 md5:3fe82285d68728a0

func X是否已配置数据库 

func X是否已配置数据库() bool

X是否已配置数据库 检查并返回数据库是否已配置。 如果存在任何配置，它将返回 true。 md5:1232e7ebd0a7ce10

func X格式化Sql 

func X格式化Sql(sql string, 参数数组 []interface{}) string

X格式化Sql 将参数绑定到SQL字符串并返回一个完整的SQL字符串，仅用于调试。 md5:1453466956e418ba

func X注册驱动 

func X注册驱动(名称 string, 驱动 Driver) error

X注册驱动 注册自定义数据库驱动到gdb。 md5:d889e7374da12918

func X添加配置组节点 

func X添加配置组节点(配置组名称 string, 配置 ConfigNode)

X添加配置组节点 向给定组的配置中添加一个节点配置。 md5:3f2a775dc2be575b

func X添加默认配置组 

func X添加默认配置组(配置组 ConfigGroup)

X添加默认配置组 将多个节点配置添加到默认组的配置中。 md5:b289b432b1f9a27f

func X添加默认配置组节点 

func X添加默认配置组节点(配置 ConfigNode)

X添加默认配置组节点 在默认组的配置中添加一个节点配置。 md5:0b566ab59e6984e4

func X获取默认组名称 

func X获取默认组名称() string

X获取默认组名称 返回默认配置的{名称}。 md5:59cc62505c297d57

func X设置全局配置 

func X设置全局配置(配置 Config)

X设置全局配置 设置包的全局配置。 它将覆盖包原有的配置。 md5:e9d794925a260f3e

func X设置组配置 

func X设置组配置(配置组名称 string, 配置 ConfigGroup)

X设置组配置 设置给定组的配置。 md5:3ca6c2845a6dcd23

func X设置默认组名称 

func X设置默认组名称(配置组名称 string)

X设置默认组名称 设置默认配置的组名。 md5:e7734b91e5838c18

func X转换到Map 

func X转换到Map(待转换值 interface{}, omitempty bool) map[string]interface{}

X转换到Map 递归地将 `value` 转换为映射类型（如果属性结构体被嵌入）。 参数 `value` 应该是 *map、map、*struct 或 struct 类型。 它支持结构体中的嵌入式结构体定义。 md5:3d9a4c7ad65d9fe1

Types

type CacheOption 

type CacheOption struct {
	// X时长 是缓存的过期时间。
	// 如果参数 `X时长` 小于 0，表示使用给定的 `Name` 清除缓存。
	// 如果参数 `X时长` 等于 0，表示永不过期。
	// 如果参数 `X时长` 大于 0，表示在 `X时长` 秒后过期。
	// md5:28707300732ac411
	X时长 time.Duration

	// X名称 是一个可选的唯一名称，用于标识缓存。
	// 通过 X名称 可以将一个名称与缓存绑定，这意味着您之后可以根据指定的名称来控制该缓存，
	// 例如更改缓存的 `持续时间` 或者清除指定名称的缓存。
	// md5:8c2eeafa42d36067
	X名称 string

	// 强制缓存查询结果，无论结果是否为nil。
	// 这用于防止缓存穿透。
	// md5:78fc7d8520d64954
	X强制缓存 bool
}

CacheOption是查询中用于模型缓存控制的选项。 md5:8a833b8335c45455

type CatchSQLManager 

type CatchSQLManager struct {
	SQLArray *garray.StrArray
	DoCommit bool // DoCommit 标记是否将提交给底层驱动器。 md5:f117644c40f63234
}

type ChunkHandler 

type ChunkHandler func(result Result, err error) bool

ChunkHandler 是一个函数，用于 Chunk 函数中，负责处理给定的结果和错误。 如果希望继续分块处理，则返回true；否则返回false以停止分块。 md5:e7b2a1b4761ac415

type Config 

type Config map[string]ConfigGroup

Config 是配置管理对象。 md5:1ef57338c678e400

type ConfigGroup 

type ConfigGroup []ConfigNode

ConfigGroup 是为指定命名组的配置节点切片。 md5:fd0679403bacd284

func X取配置组配置 

func X取配置组配置(配置组名称 string) ConfigGroup

X取配置组配置 获取并返回给定组的配置。 md5:e4487cb50b45e5f4

type ConfigNode 

type ConfigNode struct {
	Host                 string        `json:"host"`                 // 服务器的主机，可以是 IP 地址或域名，如：127.0.0.1，localhost. md5:995f8d0f775d1561
	Port                 string        `json:"port"`                 // Port, it's commonly 3306.
	User                 string        `json:"user"`                 // 身份验证用户名。 md5:bc205abcf7fb6329
	Pass                 string        `json:"pass"`                 // 认证密码。 md5:325b61eb5935f198
	Name                 string        `json:"name"`                 // 默认使用的数据库名称。 md5:13fed4b7ca845a3b
	Type                 string        `json:"type"`                 // 数据库类型：mysql，mariadb，sqlite，mssql，pgsql，oracle，clickhouse，dm。 md5:6b9f1786cf5a0d7a
	Link                 string        `json:"link"`                 // （可选）所有配置的自定义链接信息，作为一个单个字符串。 md5:cb9784decaebf7c3
	Extra                string        `json:"extra"`                // （可选）根据注册的第三方数据库驱动程序提供的额外配置。 md5:6ba9ea91183a2b0c
	Role                 string        `json:"role"`                 // （可选，默认为"master"）节点角色，用于主从模式：master, slave。 md5:9645d0e7417ebf0c
	Debug                bool          `json:"debug"`                // （可选）调试模式启用调试信息日志和输出。 md5:e292d7585b9505f9
	Prefix               string        `json:"prefix"`               //（可选）表前缀。 md5:201acb7d8a3cfba7
	DryRun               bool          `json:"dryRun"`               // （可选）空跑特性，只执行 SELECT 语句，而不执行 INSERT/UPDATE/DELETE 语句。 md5:3983d4a8bb269d45
	Weight               int           `json:"weight"`               // （可选）用于负载均衡计算的权重，如果只有一个节点则无效。 md5:6be8657f1809396b
	Charset              string        `json:"charset"`              // (可选，默认为 "utf8") 操作数据库时使用的自定义字符集。 md5:e63288ee7f2834e2
	Protocol             string        `json:"protocol"`             // （可选， 默认为 "tcp"）有关可用网络的更多信息，请参阅 net.Dial。 md5:96a17fcac4ef394d
	Timezone             string        `json:"timezone"`             // （可选）设置时区，用于显示和解释时间戳。 md5:f1c54d7158bc5e89
	Namespace            string        `json:"namespace"`            // （可选）某些数据库的命名空间。例如，在pgsql中，`Name` 用作 `catalog`，而 `NameSpace` 用作 `schema`。 md5:8dc2fa65d951a94e
	MaxIdleConnCount     int           `json:"maxIdle"`              //（可选）底层连接池的最大空闲连接配置。 md5:b1f10cf73af643a1
	MaxOpenConnCount     int           `json:"maxOpen"`              //（可选）底层连接池的最大打开连接配置。 md5:bd8ec40915479f50
	MaxConnLifeTime      time.Duration `json:"maxLifeTime"`          // （可选）连接在被关闭之前允许的最大空闲时间。 md5:b078efc5d928800a
	QueryTimeout         time.Duration `json:"queryTimeout"`         // （可选）每个DQL查询的最大时间。 md5:4c57cb456fb2ee8b
	ExecTimeout          time.Duration `json:"execTimeout"`          // (可选) DML的最大执行时间。 md5:481b9bbde2c49552
	TranTimeout          time.Duration `json:"tranTimeout"`          //（可选）事务的最大执行时间。 md5:8e1cd855a33e2c6b
	PrepareTimeout       time.Duration `json:"prepareTimeout"`       // （可选）准备操作的最大执行时间。 md5:14739995bdfab318
	CreatedAt            string        `json:"createdAt"`            // （可选）自动填充创建时间的字段名。 md5:85fd52001481b733
	UpdatedAt            string        `json:"updatedAt"`            //（可选）自动填充更新日期时间的表字段名称。 md5:5d4aa50ffafb9f8e
	DeletedAt            string        `json:"deletedAt"`            //（可选）自动填充更新日期时间的表字段名称。 md5:5d4aa50ffafb9f8e
	TimeMaintainDisabled bool          `json:"timeMaintainDisabled"` // （可选）禁用自动时间保持功能。 md5:082a8741b2590acc
}

ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) ConfigNode 是一个节点的配置信息。 备注: 此配置结构不做名称翻译, 防止通过map载入配置时, 会直接将文本名称转换成配置项名称, 导致找不到原名的配置项. (2024-07-21) md5:c441354f84b63933

type Core 

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

Core 是数据库管理的基础结构。 md5:9f4e8f0e026a368e

func (*Core) FormatUpsert 

func (c *Core) FormatUpsert(columns []string, list Map数组, option DoInsertOption) (string, error)

FormatUpsert 格式化并返回用于 UPSERT 语句的 SQL 子句部分。 在默认实现中，此函数执行类似 MySQL 的 UPSERT 语句： `INSERT INTO ... ON DUPLICATE KEY UPDATE x=VALUES(z),m=VALUES(y)...` md5:c1c6d7b14661682b

func (*Core) GetAll别名 

func (c *Core) GetAll别名(上下文 context.Context, sql string, 参数 ...interface{}) (Result, error)

GetAll别名 从数据库中查询并返回数据记录。 md5:dfdcfddaa70ab1d4

func (*Core) IsSoftCreatedFieldName 

func (c *Core) IsSoftCreatedFieldName(fieldName string) bool

IsSoftCreatedFieldName 检查并返回给定字段名是否为自动填充的创建时间。 md5:f4c7129bbccec8aa

func (Core) MarshalJSON 

func (c Core) MarshalJSON() ([]byte, error)

MarshalJSON 实现了 json.Marshal 接口的MarshalJSON方法。它只是返回指针地址。

注意，这个接口主要是为了解决 Golang 版本小于 v1.14 时的json无限循环bug而实现的。 md5:1b2346be8e04b5fa

func (*Core) Stats 

func (c *Core) Stats(ctx context.Context) []StatsItem

Stats获取并返回所有已建立节点的池统计信息。 md5:83a29e795d6705a8

func (*Core) X事务 

func (c *Core) X事务(上下文 context.Context, 回调函数 func(上下文 context.Context, tx TX) error) (错误 error)

X事务 包装了使用函数 `f` 执行的事务逻辑。 如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。如果函数 `f` 返回 nil，它将提交事务并返回 nil。

注意，在函数 `f` 中不应手动提交或回滚事务，因为这些操作将由这个函数自动处理。 md5:8906440d4dbbef1f

func (*Core) X事务开启 

func (c *Core) X事务开启(上下文 context.Context) (事务对象 TX, 错误 error)

X事务开启 启动并返回事务对象。 如果不再使用事务，你应该调用事务对象的Commit或Rollback方法。 Commit或Rollback方法也会自动关闭事务。 md5:cca0e58680665343

func (*Core) X关联对象 

func (c *Core) X关联对象(关联结构体 ...interface{}) *Model

X关联对象 根据给定对象的元数据创建并返回一个ORM模型。 md5:18604e26c0c946fb

func (*Core) X关闭数据库 

func (c *Core) X关闭数据库(上下文 context.Context) (错误 error)

X关闭数据库 方法关闭数据库并阻止新的查询开始。 随后，X关闭数据库 会等待所有已在服务器上开始处理的查询完成。

关闭 DB 实例是很少见的操作，因为 DB 处理句柄设计为长生命周期的， 并且旨在多个 goroutine 间共享。 md5:39e5c90e1da0ee5e

func (*Core) X切换数据库 

func (c *Core) X切换数据库(数据库名 string) *Schema

X切换数据库 创建并返回一个模式。 md5:2857e60cfa18e20e

func (*Core) X创建Model对象 

func (c *Core) X创建Model对象(表名或结构体 ...interface{}) *Model

X创建Model对象 根据给定的模式创建并返回一个新的ORM模型。 参数 `tableNameQueryOrStruct` 可以是多个表名，也可以是别名，例如：

  1. 模型名称： db.X创建Model对象("user") db.X创建Model对象("user u") db.X创建Model对象("user, user_detail") db.X创建Model对象("user u, user_detail ud")
  2. 带别名的模型名称： db.X创建Model对象("user", "u")
  3. 带子查询的模型名称： db.X创建Model对象("? AS a, ? AS b", subQuery1, subQuery2)

md5:add855a912a9b6ef

func (*Core) X删除 

func (c *Core) X删除(上下文 context.Context, 表名称 string, 条件 interface{}, 参数 ...interface{}) (结果 sql.Result, 错误 error)

X删除 执行 "DELETE FROM ... " 语句针对该表。

`condition` 参数可以是字符串、映射、gmap、切片、结构体或指向结构体的指针等多种类型。 它常与参数 `args` 一起使用。 例如： "uid=10000", "uid", 10000 "money>? AND name like ?", 99999, "vip_%" "status IN (?)", g.Slice{1,2,3} "age IN(?,?)", 18, 50 User{ Id : 1, UserName : "john"}. md5:c6c87830434eba7d

func (*Core) X删除所有表查询缓存 

func (c *Core) X删除所有表查询缓存(上下文 context.Context) (错误 error)

X删除所有表查询缓存 从缓存中移除所有已缓存的SQL结果. md5:1cafe85ca7b9f62d

func (*Core) X删除表字段所有缓存 

func (c *Core) X删除表字段所有缓存(上下文 context.Context) (错误 error)

X删除表字段所有缓存 删除当前配置组中所有缓存的表字段。 md5:2b2f2ebba86cfda6

func (*Core) X删除表字段缓存 

func (c *Core) X删除表字段缓存(上下文 context.Context, 表名称 string, schema ...string) (错误 error)

X删除表字段缓存 清除当前配置组中特定的缓存表字段。 md5:061271b8a4f298a0

func (*Core) X删除表查询缓存 

func (c *Core) X删除表查询缓存(上下文 context.Context, 表名称 string) (错误 error)

X删除表查询缓存 删除特定表的缓存SQL结果。 md5:5849435c2385500b

func (*Core) X原生SQL 

func (c *Core) X原生SQL(原生Sql string, 参数 ...interface{}) *Model

X原生SQL根据原始SQL（而不是表）创建并返回一个模型。示例： 

db.X原生SQL("SELECT * FROM `user` WHERE `name` = ?", "john").Scan(&result)

md5:0865d39f2ab854cb

func (*Core) X原生SQL执行 

func (c *Core) X原生SQL执行(上下文 context.Context, sql string, 参数 ...interface{}) (结果 sql.Result, 错误 error)

X原生SQL执行 将一个查询 SQL 执行到底层驱动并返回执行结果。它最常用于数据插入和更新。 md5:6f9ddc85964b9797

func (*Core) X原生SQL查询 

func (c *Core) X原生SQL查询(上下文 context.Context, sql string, 参数 ...interface{}) (结果 Result, 错误 error)

X原生SQL查询 向底层驱动提交一个查询SQL并返回执行结果。 它最常用于数据查询。 md5:06bbbfc29aa3894b

func (*Core) X原生SQL查询到结构体指针 

func (c *Core) X原生SQL查询到结构体指针(上下文 context.Context, 结构体指针 interface{}, sql string, 参数 ...interface{}) error

X原生SQL查询到结构体指针 从数据库查询一个或多个记录，并将它们转换为给定的结构体或结构体数组。

如果参数 `pointer` 是结构体指针类型，它内部会调用 GetStruct 进行转换。如果参数 `pointer` 是切片类型，它内部会调用 GetStructs 进行转换。 md5:c1dbdab7a7c29c51

func (*Core) X原生SQL查询单条记录 

func (c *Core) X原生SQL查询单条记录(上下文 context.Context, sql string, 参数 ...interface{}) (Record, error)

X原生SQL查询单条记录 从数据库中查询并返回一条记录。 md5:9552f7e095f58141

func (*Core) X原生SQL查询字段值 

func (c *Core) X原生SQL查询字段值(上下文 context.Context, sql string, 参数 ...interface{}) (Value, error)

X原生SQL查询字段值 从数据库查询并返回字段值。 SQL 应该只查询数据库中的一个字段，否则它将只返回结果中的一个字段。 md5:96794360fadbc288

func (*Core) X原生SQL查询字段计数 

func (c *Core) X原生SQL查询字段计数(上下文 context.Context, sql string, 参数 ...interface{}) (int, error)

X原生SQL查询字段计数 从数据库中查询并返回计数。 md5:a8368d39f4a58979

func (*Core) X原生SQL查询数组 

func (c *Core) X原生SQL查询数组(上下文 context.Context, sql string, 参数 ...interface{}) ([]Value, error)

X原生SQL查询数组 从数据库查询并返回数据值作为切片。 注意，如果结果中有多个列，它会随机返回一列的值。 md5:b81cd4c5e063a6f2

func (*Core) X原生sql取参数预处理对象 

func (c *Core) X原生sql取参数预处理对象(上下文 context.Context, sql string, 是否主节点执行 ...bool) (*Stmt, error)

X原生sql取参数预处理对象 准备一个预编译语句，供后续查询或执行使用。 可以从返回的语句对象并发运行多个查询或执行。 当不再需要语句时，调用者必须调用 statement 的 Close 方法。

参数 `execOnMaster` 指定是否在主节点上执行 SQL，如果配置了主从复制，则在从节点上执行。 md5:639eebcae369b0a2

func (*Core) X原生sql记录到行记录数组对象 

func (c *Core) X原生sql记录到行记录数组对象(上下文 context.Context, 底层数据记录 *sql.Rows) (Result, error)

X原生sql记录到行记录数组对象 将底层的 sql.Rows 数据记录类型转换为 Result 类型。 md5:ae9065176ef07b2e

func (*Core) X取Core对象 

func (c *Core) X取Core对象() *Core

X取Core对象 返回底层的 *Core 对象。 md5:b7d2ff344b9a6a33

func (*Core) X取DB对象 

func (c *Core) X取DB对象() DB

X取DB对象 返回底层的DB。 md5:5ebeb6e695bd2a8a

func (*Core) X取上下文对象 

func (c *Core) X取上下文对象() context.Context

X取上下文对象 返回当前数据库的上下文。 如果之前没有设置上下文，则返回 `context.Background()`。 md5:9b56f79a5eaa891e

func (*Core) X取主节点对象 

func (c *Core) X取主节点对象(数据库名称 ...string) (*sql.DB, error)

X取主节点对象 如果配置了主从节点，则创建并返回一个与主节点的连接。 如果未配置主从节点，则返回默认连接。 md5:0bd77b596cdae9a3

func (*Core) X取从节点对象 

func (c *Core) X取从节点对象(数据库名称 ...string) (*sql.DB, error)

如果配置了主从模式，X取从节点对象 会创建并返回一个从节点连接。如果没有配置主从模式，则返回默认连接。 md5:d92640050cf063d3

func (*Core) X取字段信息对象 

func (c *Core) X取字段信息对象(上下文 context.Context, 字段名称, 表名称, 数据库名称 string) *TableField

X取字段信息对象 通过字段名获取并返回该字段的类型对象。 md5:eeebff59dbaf1064

func (*Core) X取字段类型 

func (c *Core) X取字段类型(上下文 context.Context, 字段名称, 表名称, 数据库名称 string) string

X取字段类型 通过名称检索并返回指定字段的字段类型字符串。 md5:aeb8d310c854c45a

func (*Core) X取当前节点配置 

func (c *Core) X取当前节点配置() *ConfigNode

X取当前节点配置 返回当前使用的节点配置。 md5:c953d82ac4cddf35

func (*Core) X取数据库链接信息 

func (c *Core) X取数据库链接信息() string

X取数据库链接信息获取并返回经过过滤的`linkInfo`，这些信息可用于日志记录或跟踪目的。 md5:5d3d4d2f55af0347

func (*Core) X取数据库链接对象 

func (c *Core) X取数据库链接对象(上下文 context.Context, 主节点 bool, schema string) (Link, error)

X取数据库链接对象 创建并返回底层数据库链接对象，并进行事务检查。 参数 `master` 指定在配置了主从的情况下是否使用主节点。 md5:51315fe7b2e9a929

func (*Core) X取日志记录器 

func (c *Core) X取日志记录器() glog.ILogger

X取日志记录器 返回 ORM 的日志记录器。 md5:8fc6f96186fd98c6

func (*Core) X取空跑特性 

func (c *Core) X取空跑特性() bool

X取空跑特性 返回DryRun的值。 md5:7e133dad1f0ee7ba

func (*Core) X取缓存对象 

func (c *Core) X取缓存对象() *gcache.Cache

X取缓存对象 返回内部的缓存对象。 md5:3d83a15ed3d14950

func (*Core) X取表前缀 

func (c *Core) X取表前缀() string

X取表前缀 返回配置的表前缀字符串。 md5:637396955caa18c4

func (*Core) X取表名称数组 

func (c *Core) X取表名称数组(上下文 context.Context, schema ...string) (表名称数组 []string, 错误 error)

X取表名称数组 获取并返回当前模式下的表格列表。 主要用于命令行工具链，用于自动生成模型。 md5:bce161ba95454bf5

func (*Core) X取表名称缓存 

func (c *Core) X取表名称缓存() ([]string, error)

X取表名称缓存 使用缓存检索并返回当前数据库中的表名。 md5:9abf0a08a0dbc629

func (*Core) X取表字段信息Map 

func (c *Core) X取表字段信息Map(上下文 context.Context, 表名称 string, schema ...string) (字段信息Map map[string]*TableField, 错误 error)

X取表字段信息Map 获取并返回当前模式指定表的字段信息。

参数 `link` 是可选的，如果为 nil，则自动获取一个原始 SQL 连接，用于执行必要的 SQL 查询。

它返回一个包含字段名及其对应字段的映射。由于映射是无序的，TableField 结构体有一个 "Index" 字段，标记其在字段中的顺序。

该方法使用缓存功能来提高性能，直到进程重启，缓存永不过期。 md5:c844572d5210b35e

func (*Core) X取调试模式 

func (c *Core) X取调试模式() bool

X取调试模式 返回调试值。 md5:9bffedbe7bd8f1cf

func (*Core) X取超时上下文对象 

func (c *Core) X取超时上下文对象(上下文 context.Context, 超时类型 int) (context.Context, context.CancelFunc)

X取超时上下文对象 返回指定超时类型的上下文和取消函数。 md5:5d0be7078de61c6d

func (*Core) X取配置组名称 

func (c *Core) X取配置组名称() string

X取配置组名称 返回配置的组字符串。 md5:fb5b1b36ae36c283

func (*Core) X取默认数据库名称 

func (c *Core) X取默认数据库名称() string

X取默认数据库名称 返回已配置的模式。 md5:89a8c016a19c9022

func (*Core) X向主节点发送心跳 

func (c *Core) X向主节点发送心跳() error

X向主节点发送心跳 向主节点发送请求以检查身份验证或保持连接活动。 md5:47a7df55cbee8583

func (*Core) X向从节点发送心跳 

func (c *Core) X向从节点发送心跳() error

PingSlave 调用ping命令检查从节点的认证或者维持连接。 md5:62272b38d874eda6

func (*Core) X多表去重查询 

func (c *Core) X多表去重查询(Model对象 ...*Model) *Model

X多表去重查询 执行 "(SELECT xxx FROM xxx) UNION (SELECT xxx FROM xxx) ..." 语句。 md5:6a2f9809c172cb31

func (*Core) X多表查询 

func (c *Core) X多表查询(Model对象 ...*Model) *Model

X多表查询 生成 "(SELECT xxx FROM xxx) UNION ALL (SELECT xxx FROM xxx) ... " 语句。 md5:5a15c8720fcb152f

func (*Core) X底层CheckLocalTypeForField 

func (c *Core) X底层CheckLocalTypeForField(ctx context.Context, fieldType string, fieldValue interface{}) (LocalType, error)

X底层CheckLocalTypeForField 检查并返回与给定数据库类型相对应的本地类型。 md5:d3191e6393b7e531

func (*Core) X底层ConvertDataForRecord 

func (c *Core) X底层ConvertDataForRecord(上下文 context.Context, 值 interface{}, 表名称 string) (map[string]interface{}, error)

X底层ConvertDataForRecord 是一个非常重要的函数，用于将任何数据转换为 以便将其作为记录插入到表或集合中。

参数 `value` 应为 *map/map/*struct/struct 类型。 对于结构体，它支持嵌入式结构体定义。 md5:27b867ec3a1c3c1d

func (*Core) X底层ConvertValueForField 

func (c *Core) X底层ConvertValueForField(ctx context.Context, fieldType string, fieldValue interface{}) (interface{}, error)

X底层ConvertValueForField 将值转换为记录字段的类型。 参数 `fieldType` 是目标记录字段。 参数 `fieldValue` 是要写入记录字段的值。 md5:196c02c9f6cf3380

func (*Core) X底层ConvertValueForLocal 

func (c *Core) X底层ConvertValueForLocal(
	ctx context.Context, fieldType string, fieldValue interface{},
) (interface{}, error)

X底层ConvertValueForLocal 根据从数据库中获取的字段类型名称，将值转换为Go语言中的本地类型。 参数 `fieldType` 为小写格式，例如： `float(5,2)`，`unsigned double(5,2)`，`decimal(10,2)`，`char(45)`，`varchar(100)` 等。 md5:7e1ede2b68158e31

func (*Core) X底层DoCommit 

func (c *Core) X底层DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutput, err error)

X底层DoCommit 将当前SQL和参数提交给底层SQL驱动程序。 md5:7cf9b1f6f4d9d2cb

func (*Core) X底层DoFilter 

func (c *Core) X底层DoFilter(ctx context.Context, link Link, sql string, args []interface{}) (newSql string, newArgs []interface{}, err error)

X底层DoFilter 是一个钩子函数，它在 SQL 语句及其参数提交给底层驱动之前进行过滤。 参数 `link` 指定当前数据库连接的操作对象。在 SQL 语句 `sql` 及其参数 `args` 被提交给驱动之前，您可以根据需要随意修改它们。 md5:41118fbc4e6c5562 

func (c *Core) X底层MasterLink(schema ...string) (Link, error)

X底层MasterLink 类似于函数 Master，但增加了 `schema` 参数，用于指定连接的模式。 这个函数主要用于内部使用。同时也参考 Master 函数。 md5:ae74b996555aea95

func (*Core) X底层QuoteString 

func (c *Core) X底层QuoteString(s string) string

X底层QuoteString 使用引号字符对字符串进行引用。例如这样的字符串： "user", "user u", "user,user_detail", "user u, user_detail ut", "u.id asc".

`string` 的含义可以理解为作为包含列名的语句字符串的一部分。 md5:09c5263950e9ed1a

func (*Core) X底层QuoteWord 

func (c *Core) X底层QuoteWord(s string) string

X底层QuoteWord 检查给定的字符串 `s` 是否为一个单词， 如果是，它将使用数据库的安全字符对 `s` 进行转义，并返回带引号的字符串；否则，返回原始字符串不做任何更改。

可以认为一个 `word` 表示列名。 md5:71291615d7bcffe0 

func (c *Core) X底层SlaveLink(schema ...string) (Link, error)

X底层SlaveLink 行为类似于 Slave 函数，但增加了 `schema` 参数，用于指定连接的模式。它主要用于内部使用。 参阅 Slave。 md5:8a8929395882c04a

func (*Core) X底层_GetIgnoreResultFromCtx 

func (c *Core) X底层_GetIgnoreResultFromCtx(ctx context.Context) bool

func (*Core) X底层_InjectIgnoreResult 

func (c *Core) X底层_InjectIgnoreResult(ctx context.Context) context.Context

func (*Core) X底层删除 

func (c *Core) X底层删除(上下文 context.Context, 链接 Link, 表名称 string, 条件 string, 参数 ...interface{}) (结果 sql.Result, 错误 error)

X底层删除 对表执行 "DELETE FROM ..." 语句。 此函数通常用于自定义接口定义，无需手动调用。 md5:f902004d44b55d73

func (*Core) X底层原生SQL执行 

func (c *Core) X底层原生SQL执行(上下文 context.Context, 链接 Link, sql string, 参数 ...interface{}) (结果 sql.Result, 错误 error)

X底层原生SQL执行 通过给定的链接对象将 sql 字符串及其参数提交到底层驱动，并返回执行结果。 md5:947bd2b83e751e10

func (*Core) X底层原生SQL查询 

func (c *Core) X底层原生SQL查询(上下文 context.Context, 链接 Link, sql string, 参数 ...interface{}) (结果 Result, 错误 error)

X底层原生SQL查询 通过给定的链接对象将SQL字符串及其参数提交给底层驱动，并返回执行结果。 md5:af7bdcd1a2074bc0

func (*Core) X底层原生sql参数预处理对象 

func (c *Core) X底层原生sql参数预处理对象(上下文 context.Context, 链接 Link, sql string) (参数预处理 *Stmt, 错误 error)

X底层原生sql参数预处理对象 会调用给定链接对象上的prepare函数，并返回语句对象。 md5:bae03ede256987bd

func (*Core) X底层取数据库安全字符 

func (c *Core) X底层取数据库安全字符() (左字符 string, 右字符 string)

X底层取数据库安全字符 返回当前数据库的安全字符。在默认情况下，它不执行任何操作。 md5:681b4cc93b5adecd

func (*Core) X底层插入 

func (c *Core) X底层插入(上下文 context.Context, 链接 Link, 表名称 string, list Map数组, option DoInsertOption) (result sql.Result, err error)

X底层插入 函数用于插入或更新给定表的数据。 这个函数通常用于自定义接口定义，不需要手动调用。 参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。 示例： Data(g.Map{"uid": 10000, "name":"john"}) Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"}})

参数 `option` 的值如下： InsertOptionDefault：仅插入，如果数据中包含唯一键或主键，会返回错误； InsertOptionReplace：如果数据中包含唯一键或主键，会先从表中删除再插入新的记录； InsertOptionSave： 如果数据中包含唯一键或主键，会进行更新，否则插入新记录； InsertOptionIgnore： 如果数据中包含唯一键或主键，忽略插入操作。 md5:e9554638335c9c80

func (*Core) X底层更新 

func (c *Core) X底层更新(上下文 context.Context, 链接 Link, 表名称 string, 值 interface{}, 条件 string, 参数 ...interface{}) (result sql.Result, err error)

X底层更新 执行针对表的 "UPDATE ... " 语句。 这个函数通常用于自定义接口定义，一般不需要手动调用。 md5:6d7e08b57dd59a0b

func (*Core) X底层查询 

func (c *Core) X底层查询(上下文 context.Context, 链接 Link, sql string, 参数 ...interface{}) (结果 Result, 错误 error)

X底层查询 从数据库查询并返回数据记录。 md5:82b06146b8d539d1

func (*Core) X底层添加前缀字符和引用字符 

func (c *Core) X底层添加前缀字符和引用字符(表名称 string) string

X底层添加前缀字符和引用字符 为表名添加前缀字符串并包围引号。 它可以处理如下形式的表字符串： "user", "user u", "user,user_detail", "user u, user_detail ut", "user as u, user_detail as ut".

请注意，此函数会自动检查表前缀是否已经添加， 如果是，则不对表名做任何处理，否则会在表名前添加前缀。 md5:46ab3c3833cc0124

func (*Core) X插入 

func (c *Core) X插入(上下文 context.Context, 表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入 执行 "INSERT INTO..." 语句来操作表。 如果表中已经存在数据的唯一记录，它会返回错误。

参数 `data` 可以是 map、gmap、struct、*struct、[]map 或 []struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

参数 `batch` 在给定数据为切片时，指定批量操作的次数。 md5:fd75d343f485b8dc

func (*Core) X插入并取ID 

func (c *Core) X插入并取ID(上下文 context.Context, 表名称 string, 值 interface{}, 批量操作行数 ...int) (int64, error)

X插入并取ID 执行插入操作，并返回自动生成的最后一个插入id。 md5:8d00b40a35fa48a5

func (*Core) X插入并更新已存在 

func (c *Core) X插入并更新已存在(上下文 context.Context, 表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并更新已存在 执行 "INSERT INTO ... ON DUPLICATE KEY UPDATE..." 语句来操作表。 如果保存的数据中存在主键或唯一索引，它将更新记录；否则，将在表中插入新记录。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

如果给定的数据是切片类型，它将进行批量保存。可选参数 `batch` 指定了批量操作的次数。 md5:c76721f5e0b01424

func (*Core) X插入并替换已存在 

func (c *Core) X插入并替换已存在(上下文 context.Context, 表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并替换已存在 用于执行针对该表的 "REPLACE INTO..." 语句。如果表中已经存在数据的唯一记录，它会删除该记录并插入新的。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。如果给定的数据是切片类型，它将进行批量替换，并可选地通过参数 `batch` 指定批量操作次数。 md5:69ecd0994eab5bbb

func (*Core) X插入并跳过已存在 

func (c *Core) X插入并跳过已存在(上下文 context.Context, 表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并跳过已存在 执行 "INSERT IGNORE INTO ..." 语句针对该表。 如果表中已存在该数据的唯一记录，则忽略插入操作。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"})

当给定的数据为切片时，参数 `batch` 指定批处理操作的计数。 md5:49f76901041c9819

func (*Core) X是否存在字段 

func (c *Core) X是否存在字段(上下文 context.Context, 表名称, 字段名称 string, schema ...string) (bool, error)

X是否存在字段 用于判断该字段是否存在于表中。 md5:e26ad0ecb292096b

func (*Core) X是否存在表名 

func (c *Core) X是否存在表名(表名称 string) (bool, error)

X是否存在表名 判断数据库中是否存在指定的表名。 md5:64f8bb54ba260c03

func (*Core) X更新 

func (c *Core) X更新(上下文 context.Context, 表名称 string, 数据 interface{}, 条件 interface{}, 参数 ...interface{}) (sql.Result, error)

X更新 执行表的 "UPDATE ... " 语句。

参数 `data` 可以是字符串、映射、gmap、结构体或指向结构体的指针等类型。 例如："uid=10000", "uid", 10000, g.Map{"uid": 10000, "name":"john"}

参数 `condition` 也可以是字符串、映射、gmap、切片或结构体及指向结构体的指针等类型。 常与参数 `args` 配合使用。 例如： "uid=10000", "uid", 10000 "money>? AND name like ?", 99999, "vip_%" "status IN (?)", g.Slice{1,2,3} "age IN(?,?)", 18, 50 User{ Id : 1, UserName : "john"}. md5:8651eb1bd7e10da0

func (*Core) X格式化Sql 

func (c *Core) X格式化Sql(sql string, 参数数组 []interface{}) (新sql string, 新参数数组 []interface{})

X格式化Sql 在执行SQL之前格式化SQL字符串及其参数。 在SQL执行过程中，内部的handleArguments函数可能会被调用两次， 但请不必担心，这是安全且高效的。 md5:73af1c35794cea21

func (*Core) X设置上下文并取副本 

func (c *Core) X设置上下文并取副本(上下文 context.Context) DB

X设置上下文并取副本是一个链式函数，它创建并返回一个新的DB对象，它是当前DB对象的浅拷贝，并且包含了给定的上下文。 注意，这个返回的DB对象只能使用一次，所以不要将其分配给全局变量或长期使用的包变量。 md5:9dfddec16d5df9f5

func (*Core) X设置日志记录器 

func (c *Core) X设置日志记录器(日志记录器 glog.ILogger)

X设置日志记录器为ORM设置日志记录器。 md5:a70ca86920e39e54

func (*Core) X设置最大打开连接数 

func (c *Core) X设置最大打开连接数(连接数 int)

X设置最大打开连接数 设置到数据库的最大打开连接数。

如果 MaxIdleConns 大于 0，并且新的 MaxOpenConns 小于 MaxIdleConns，那么 MaxIdleConns 将被调整为与新的 MaxOpenConns 限制相匹配。

如果 n 小于或等于 0，则没有对打开连接数的限制。默认值为 0（无限制）。 md5:e8cfc3ecf7f5887e

func (*Core) X设置最大空闲时长 

func (c *Core) X设置最大空闲时长(时长 time.Duration)

X设置最大空闲时长 设置连接可被重用的最大时间。

过期的连接可能会在被重用前被惰性关闭。

如果 d <= 0，则连接不会因为超时而被关闭。 md5:f8d0da250f6387ba

func (*Core) X设置最大闲置连接数 

func (c *Core) X设置最大闲置连接数(连接数 int)

X设置最大闲置连接数 设置空闲连接池中的最大连接数。

如果 MaxOpenConns 大于 0 但小于新的 MaxIdleConns，那么新的 MaxIdleConns 将被调整为与 MaxOpenConns 的限制相匹配。

如果 n 小于或等于 0，则不保留任何空闲连接。

当前默认的最大空闲连接数为 2。这可能会在未来的版本中改变。 md5:7d6f4079c0bfc25f

func (*Core) X设置空跑特性 

func (c *Core) X设置空跑特性(开启 bool)

X设置空跑特性 启用/禁用DryRun功能。 md5:359f8392ba799c27

func (*Core) X设置调试模式 

func (c *Core) X设置调试模式(开启 bool)

X设置调试模式 启用/禁用调试模式。 md5:44a23ae9ad388bd8

type Counter 

type Counter struct {
	X字段名称 string
	X增减值  float64
}

Counter 是更新计数的类型。 md5:d05ba3f2911b8013

type DB 

type DB interface {

	// X创建Model对象 根据给定的模式创建并返回一个新的 ORM 模型。
	// 参数 `table` 可以是多个表名，也可以包括别名，例如：
	// 1. 模型名称：
	//    X创建Model对象("user")
	//    X创建Model对象("user u") 	// u 作为 user 表的别名
	//    X创建Model对象("user, user_detail") 	// 多个模型名称
	//    X创建Model对象("user u, user_detail ud") 	// 多个模型名称及别名
	// 2. 带别名的模型名称：X创建Model对象("user", "u") 	// 第二个参数指定别名
	// 参见 Core.X创建Model对象 了解更多。
	// md5:61d3e6d835068122
	X创建Model对象(tableNameOrStruct ...interface{}) *Model

	// X原生SQL 根据原始SQL（而不是表格）创建并返回一个模型。 md5:96066a9d41296a2a
	X原生SQL(rawSql string, args ...interface{}) *Model

	// X切换数据库 创建并返回一个模式。
	// 参见 Core.X切换数据库。
	// md5:0f4472ee79f06819
	X切换数据库(schema string) *Schema

	// X关联对象根据给定对象的元数据创建并返回一个ORM模型。同时参见Core.X关联对象。
	// md5:78ab17ce6b00ce6e
	X关联对象(objects ...interface{}) *Model

	// X底层Open 使用给定的节点配置为数据库创建一个原始连接对象。
	// 注意，不建议手动使用此函数。
	// 另请参阅 DriverMysql.X底层Open。
	// md5:1021f26472df579e
	X底层Open(config *ConfigNode) (*sql.DB, error)

	// X设置上下文并取副本 是一个链式函数，它创建并返回一个新的 DB，该 DB 是当前 DB 对象的浅拷贝，并在其中设置了给定的上下文。
	// 另请参阅 Core.X设置上下文并取副本。
	// md5:7eec5fab912764e7
	X设置上下文并取副本(ctx context.Context) DB

	// X关闭数据库 关闭数据库并阻止新的查询开始。然后，X关闭数据库 等待已经在服务器上开始处理的所有查询完成。
	//
	// 通常不会关闭 DB，因为 DB句柄应该是长期存在的，并且在多个 goroutine 之间共享。
	// md5:0985fc8e558f83fc
	X关闭数据库(ctx context.Context) error

	X原生SQL查询(ctx context.Context, sql string, args ...interface{}) (Result, error)       // See Core.Query.
	X原生SQL执行(ctx context.Context, sql string, args ...interface{}) (sql.Result, error)   // See Core.Exec.
	X原生sql取参数预处理对象(ctx context.Context, sql string, execOnMaster ...bool) (*Stmt, error) // See Core.Prepare.

	X插入(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error)                               // See Core.Insert.
	X插入并跳过已存在(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error)                         // See Core.InsertIgnore.
	X插入并取ID(ctx context.Context, table string, data interface{}, batch ...int) (int64, error)                                // 参见Core.InsertAndGetId。 md5:b7dec69920da6e7a
	X插入并替换已存在(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error)                         // See Core.Replace.
	X插入并更新已存在(ctx context.Context, table string, data interface{}, batch ...int) (sql.Result, error)                         // See Core.Save.
	X更新(ctx context.Context, table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error) // See Core.Update.
	X删除(ctx context.Context, table string, condition interface{}, args ...interface{}) (sql.Result, error)                   // See Core.Delete.

	X底层查询(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)                                           // See Core.DoSelect.
	X底层插入(ctx context.Context, link Link, table string, data Map数组, option DoInsertOption) (result sql.Result, err error)                       // See Core.DoInsert.
	X底层更新(ctx context.Context, link Link, table string, data interface{}, condition string, args ...interface{}) (result sql.Result, err error) // See Core.DoUpdate.
	X底层删除(ctx context.Context, link Link, table string, condition string, args ...interface{}) (result sql.Result, err error)                   // See Core.DoDelete.

	X底层原生SQL查询(ctx context.Context, link Link, sql string, args ...interface{}) (result Result, err error)     // See Core.DoQuery.
	X底层原生SQL执行(ctx context.Context, link Link, sql string, args ...interface{}) (result sql.Result, err error) // See Core.DoExec.

	X底层DoFilter(ctx context.Context, link Link, sql string, args []interface{}) (newSql string, newArgs []interface{}, err error) // See Core.DoFilter.
	X底层DoCommit(ctx context.Context, in DoCommitInput) (out DoCommitOutput, err error)                                            // See Core.DoCommit.

	X底层原生sql参数预处理对象(ctx context.Context, link Link, sql string) (*Stmt, error) // See Core.DoPrepare.

	GetAll别名(ctx context.Context, sql string, args ...interface{}) (Result, error)                     // See Core.GetAll.
	X原生SQL查询单条记录(ctx context.Context, sql string, args ...interface{}) (Record, error)                 // See Core.GetOne.
	X原生SQL查询字段值(ctx context.Context, sql string, args ...interface{}) (Value, error)                   // See Core.GetValue.
	X原生SQL查询数组(ctx context.Context, sql string, args ...interface{}) ([]Value, error)                  // See Core.GetArray.
	X原生SQL查询字段计数(ctx context.Context, sql string, args ...interface{}) (int, error)                    // See Core.GetCount.
	X原生SQL查询到结构体指针(ctx context.Context, objPointer interface{}, sql string, args ...interface{}) error // See Core.GetScan.
	X多表去重查询(unions ...*Model) *Model                                                                   // See Core.Union.
	X多表查询(unions ...*Model) *Model                                                                     // See Core.UnionAll.

	X取主节点对象(schema ...string) (*sql.DB, error) // See Core.Master.
	X取从节点对象(schema ...string) (*sql.DB, error) // See Core.Slave.

	X向主节点发送心跳() error // See Core.PingMaster.
	X向从节点发送心跳() error // See Core.PingSlave.

	X事务开启(ctx context.Context) (TX, error)                                   // See Core.Begin.
	X事务(ctx context.Context, f func(ctx context.Context, tx TX) error) error // See Core.Transaction.

	X取缓存对象() *gcache.Cache        // See Core.GetCache.
	X设置调试模式(debug bool)           // See Core.SetDebug.
	X取调试模式() bool                 // See Core.GetDebug.
	X取默认数据库名称() string            // See Core.GetSchema.
	X取表前缀() string                // See Core.GetPrefix.
	X取配置组名称() string              // See Core.GetGroup.
	X设置空跑特性(enabled bool)         // See Core.SetDryRun.
	X取空跑特性() bool                 // See Core.GetDryRun.
	X设置日志记录器(logger glog.ILogger) // See Core.SetLogger.
	X取日志记录器() glog.ILogger        // See Core.GetLogger.
	X取当前节点配置() *ConfigNode        // See Core.GetConfig.
	X设置最大闲置连接数(n int)             // 参见 Core.SetMaxIdleConnCount。 md5:93a41dde27176210
	X设置最大打开连接数(n int)             // 参见Core.SetMaxOpenConnCount。 md5:781ba14245ef2d2f
	X设置最大空闲时长(d time.Duration)    // 请参考Core.SetMaxConnLifeTime。 md5:9886c404ca6b5919

	Stats(ctx context.Context) []StatsItem                                                                      // See Core.Stats.
	X取上下文对象() context.Context                                                                                   // See Core.GetCtx.
	X取Core对象() *Core                                                                                            // See Core.GetCore
	X底层取数据库安全字符() (charLeft string, charRight string)                                                           // See Core.GetChars.
	X取表名称数组(ctx context.Context, schema ...string) (tables []string, err error)                                 // 参见 Core.Tables。驱动程序必须实现此函数。 md5:d7f231f6b59af607
	X取表字段信息Map(ctx context.Context, table string, schema ...string) (map[string]*TableField, error)             // 参见 Core.TableFields。驱动程序必须实现此函数。 md5:657c24bb39017da1
	X底层ConvertValueForField(ctx context.Context, fieldType string, fieldValue interface{}) (interface{}, error) // 参见Core(ConvertValueForField). md5:cd3e4aabe989b5b0
	X底层ConvertValueForLocal(ctx context.Context, fieldType string, fieldValue interface{}) (interface{}, error) // 参见Core.ConvertValueForLocal. md5:c5ed8f55d002cc9b
	X底层CheckLocalTypeForField(ctx context.Context, fieldType string, fieldValue interface{}) (LocalType, error) // 参见 Core.CheckLocalTypeForField. md5:9dab404962da3137
	FormatUpsert(columns []string, list Map数组, option DoInsertOption) (string, error)                           // 参见Core.DoFormatUpsert. md5:e28a610aead90684
}

DB 定义 ORM 操作的接口。 md5:328f032182d38455

func X上下文取DB对象 

func X上下文取DB对象(上下文 context.Context) DB

X上下文取DB对象 从上下文中获取并返回DB对象。 md5:90c01e951db89218

func X创建DB对象 

func X创建DB对象(配置项 ConfigNode) (DB对象 DB, 错误 error)

X创建DB对象 根据给定的配置节点创建并返回一个ORM对象。 md5:c6039a0817062f9e

func X创建DB对象并按配置组 

func X创建DB对象并按配置组(配置组名称 ...string) (DB对象 DB, 错误 error)

X创建DB对象并按配置组 根据指定的配置组名称创建并返回一个ORM对象，带有全局配置。 参数`name`指定了配置组的名称，默认为DefaultGroupName。 md5:a15dd30e999d29e5

func X取单例对象 

func X取单例对象(配置组名称 ...string) (DB对象 DB, 错误 error)

X取单例对象 返回用于数据库操作的实例。 参数 `name` 指定配置组名称，默认为 DefaultGroupName。 md5:06c22232a9c53a60

type DoCommitInput 

type DoCommitInput struct {
	Db            *sql.DB
	Tx            *sql.Tx
	Stmt          *sql.Stmt
	Link          Link
	Sql           string
	Args          []interface{}
	Type          SqlType
	IsTransaction bool
}

DoCommitInput是DoCommit函数的输入参数。 md5:151d182ffc05e6f3

type DoCommitOutput 

type DoCommitOutput struct {
	Result sql.Result  // Result 是执行语句的结果。 md5:92181818237c3bdd
	X行记录数组 []Record    // Records 是查询语句的结果。 md5:3ab79979d5bb7a15
	X参数预处理 *Stmt       // Stmt是Prepare的结果，是一个Statement对象。 md5:f7d8689435820710
	Tx     TX          // Tx是Begin操作的结果交易对象。 md5:388468f78948bf40
	X底层结果  interface{} // RawResult 是底层结果，可能是 sql.Result/*sql.Rows/*sql.Row。 md5:8f6721571bd4ebc3
}

DoCommitOutput是DoCommit函数的输出参数。 md5:bb154a9d2f960894

type DoInsertOption 

type DoInsertOption struct {
	OnDuplicateStr string                 // 自定义的`on duplicated`语句字符串。 md5:1076eb09195a063c
	OnDuplicateMap map[string]interface{} // 从`OnDuplicateEx`函数中自定义的键值映射，用于`on duplicated`语句。 md5:11d4cf3d337093bb
	OnConflict     []string               // 自定义的更新或插入语句中的冲突键，如果数据库需要的话。 md5:9f554ee78fb66a28
	InsertOption   InsertOption           // 在常量值中插入操作。 md5:e5ca1b47e1d66f7a
	BatchCount     int                    // 批量插入的批次计数。 md5:015bd9ee24bd1f5c
}

DoInsertOption是用于DoInsert函数的输入结构体。 md5:de18cdcf6449aa9a

type Driver 

type Driver interface {
	// New 为指定的数据库服务器创建并返回一个数据库对象。 md5:27bb5dc9ab2ddbdf
	New(core *Core, node *ConfigNode) (DB, error)
}

Driver 是将 sql 驱动程序集成到 gdb 包的接口。 md5:739e8c3911355df2

type DriverDefault 

type DriverDefault struct {
	*Core
}

DriverDefault是MySQL数据库的默认驱动，它什么都不做。 md5:c3fc81ab467241cd

func (*DriverDefault) New 

func (d *DriverDefault) New(core *Core, node *ConfigNode) (DB, error)

New 创建并返回一个针对 MySQL 的数据库对象。它实现了 gdb.Driver 接口，以便于额外的数据库驱动程序安装。 md5:e61df629828efeff

func (*DriverDefault) X向主节点发送心跳 

func (d *DriverDefault) X向主节点发送心跳() error

X向主节点发送心跳 向主节点发送请求以检查身份验证或保持连接活动。 md5:47a7df55cbee8583

func (*DriverDefault) X向从节点发送心跳 

func (d *DriverDefault) X向从节点发送心跳() error

X向从节点发送心跳 调用ping命令检查从节点的认证或者维持连接。 md5:62272b38d874eda6

func (*DriverDefault) X底层Open 

func (d *DriverDefault) X底层Open(配置对象 *ConfigNode) (db *sql.DB, err error)

X底层Open 创建并返回一个底层的 sql.DB 对象，用于 MySQL。 注意，它将时间.Time 参数默认转换为本地时区。 md5:341df118003c304e

type DriverWrapper 

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

DriverWrapper是一个驱动程序包装器，用于通过嵌入式驱动程序扩展功能。 md5:7294ac58de5aa606

func (*DriverWrapper) New 

func (d *DriverWrapper) New(core *Core, node *ConfigNode) (DB, error)

New 创建并返回一个针对 MySQL 的数据库对象。它实现了 gdb.Driver 接口，以便于额外的数据库驱动程序安装。 md5:e61df629828efeff

type DriverWrapperDB 

type DriverWrapperDB struct {
	DB
}

DriverWrapperDB是一个DB包装器，用于通过嵌入式DB扩展功能。 md5:a926644143c69c76

func (*DriverWrapperDB) X取表名称数组 

func (d *DriverWrapperDB) X取表名称数组(上下文 context.Context, schema ...string) (表名称数组 []string, 错误 error)

X取表名称数组 获取并返回当前模式下的表格列表。 主要用于命令行工具链，用于自动生成模型。 md5:bce161ba95454bf5

func (*DriverWrapperDB) X取表字段信息Map 

func (d *DriverWrapperDB) X取表字段信息Map(
	ctx context.Context, table string, schema ...string,
) (fields map[string]*TableField, err error)

X取表字段信息Map 获取并返回当前模式指定表的字段信息。

参数 `link` 是可选的，如果为 nil，则自动获取一个原始 SQL 连接，用于执行必要的 SQL 查询。

它返回一个包含字段名及其对应字段的映射。由于映射是无序的，TableField 结构体有一个 "Index" 字段，标记其在字段中的顺序。

该方法使用缓存功能来提高性能，直到进程重启，缓存永不过期。 md5:c844572d5210b35e

func (*DriverWrapperDB) X底层Open 

func (d *DriverWrapperDB) X底层Open(node *ConfigNode) (db *sql.DB, err error)

X底层Open 创建并返回一个用于pgsql的底层sql.DB对象。 参考链接：https://pkg.go.dev/github.com/lib/pq md5:9889bcb899248a2b

func (*DriverWrapperDB) X底层插入 

func (d *DriverWrapperDB) X底层插入(上下文 context.Context, 链接 Link, 表名称 string, list Map数组, option DoInsertOption) (result sql.Result, err error)

X底层插入 用于插入或更新给定表的数据。 此函数通常用于自定义接口定义，您无需手动调用。 参数 `data` 可以为 map/gmap/struct/*struct/[]map/[]struct 等类型。 例如： Data(g.Map{"uid": 10000, "name":"john"}) Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"})

参数 `option` 的值如下： InsertOptionDefault：仅插入，如果数据中包含唯一键或主键，则返回错误； InsertOptionReplace：如果数据中包含唯一键或主键，先从表中删除原有记录，再插入新记录； InsertOptionSave：如果数据中包含唯一键或主键，进行更新，否则插入新记录； InsertOptionIgnore：如果数据中包含唯一键或主键，忽略插入操作。 md5:9fab32fdc41df179

type HookDeleteInput 

type HookDeleteInput struct {
	Model     *Model        // 当前操作模型。 md5:d9c5abcf43d4a0c5
	Table     string        // 将要使用的表名。更新此属性以更改目标表名。 md5:b5d4582f7fa65327
	Schema    string        // 将要使用的模式名称。更新此属性以更改目标模式名称。 md5:40385c83e27c8a07
	Condition string        // 删除操作的WHERE条件字符串。 md5:63d65a2af6b3c2b9
	Args      []interface{} // sql占位符的参数。 md5:aed81f2b97f42d86
	// contains filtered or unexported fields
}

HookDeleteInput包含删除钩子操作的参数。 md5:f7d586e1f75c0a3e

func (*HookDeleteInput) Next 

func (h *HookDeleteInput) Next(ctx context.Context) (result sql.Result, err error)

Next 调用下一个钩子处理器。 md5:7348deede95e47b0

type HookFuncDelete 

type HookFuncDelete func(ctx context.Context, in *HookDeleteInput) (result sql.Result, err error)

type HookFuncInsert 

type HookFuncInsert func(ctx context.Context, in *HookInsertInput) (result sql.Result, err error)

type HookFuncSelect 

type HookFuncSelect func(ctx context.Context, in *HookSelectInput) (result Result, err error)

type HookFuncUpdate 

type HookFuncUpdate func(ctx context.Context, in *HookUpdateInput) (result sql.Result, err error)

type HookHandler 

type HookHandler struct {
	Select HookFuncSelect
	Insert HookFuncInsert
	Update HookFuncUpdate
	Delete HookFuncDelete
}

HookHandler 管理Model支持的所有钩子函数。 md5:bc5db27f3bf00d12

type HookInsertInput 

type HookInsertInput struct {
	Model  *Model         // 当前操作模型。 md5:d9c5abcf43d4a0c5
	Table  string         // 将要使用的表名。更新此属性以更改目标表名。 md5:b5d4582f7fa65327
	Schema string         // 将要使用的模式名称。更新此属性以更改目标模式名称。 md5:40385c83e27c8a07
	Data   Map数组          // 要插入/保存到表中的数据记录列表。 md5:af6867e8ee9b8dd5
	Option DoInsertOption // 用于数据插入的额外选项。 md5:ffac0ff130d3b693
	// contains filtered or unexported fields
}

HookInsertInput 插入钩子操作的参数。 md5:76f9069cc685c571

func (*HookInsertInput) Next 

func (h *HookInsertInput) Next(上下文 context.Context) (行记录数组 sql.Result, 错误 error)

Next 调用下一个钩子处理器。 md5:7348deede95e47b0

type HookSelectInput 

type HookSelectInput struct {
	Model  *Model        // 当前操作模型。 md5:d9c5abcf43d4a0c5
	Table  string        // 将要使用的表名。更新此属性以更改目标表名。 md5:b5d4582f7fa65327
	Schema string        // 将要使用的模式名称。更新此属性以更改目标模式名称。 md5:40385c83e27c8a07
	Sql    string        // 将要提交的SQL字符串。 md5:7c6c74bdd4ed9bb2
	Args   []interface{} // The arguments of sql.
	// contains filtered or unexported fields
}

HookSelectInput 存储选择操作的参数。 注意，COUNT 语句也会被此功能捕获，这通常对上层业务钩子处理程序不感兴趣。 md5:c5f22bccaae80481

func (*HookSelectInput) Next 

func (h *HookSelectInput) Next(上下文 context.Context) (行记录数组 Result, 错误 error)

Next 调用下一个钩子处理器。 md5:7348deede95e47b0

type HookUpdateInput 

type HookUpdateInput struct {
	Model     *Model        // 当前操作模型。 md5:d9c5abcf43d4a0c5
	Table     string        // 将要使用的表名。更新此属性以更改目标表名。 md5:b5d4582f7fa65327
	Schema    string        // 将要使用的模式名称。更新此属性以更改目标模式名称。 md5:40385c83e27c8a07
	Data      interface{}   // `Data` 可以是类型：map[string]interface{} 或 string。你可以对 `Data` 进行类型断言。 md5:f92fddf82f17883a
	Condition string        // 用于更新的条件字符串。 md5:4bcf07b70ed87d5a
	Args      []interface{} // sql占位符的参数。 md5:aed81f2b97f42d86
	// contains filtered or unexported fields
}

HookUpdateInput 表示更新钩子操作的参数。 md5:a9d35fc8f42cd434

func (*HookUpdateInput) Next 

func (h *HookUpdateInput) Next(上下文 context.Context) (行记录数组 sql.Result, 错误 error)

Next 调用下一个钩子处理器。 md5:7348deede95e47b0

type InsertOption 

type InsertOption int
const (
	InsertOptionDefault InsertOption = iota
	InsertOptionReplace
	InsertOptionSave
	InsertOptionIgnore
)
type Link interface {
	QueryContext(ctx context.Context, sql string, args ...interface{}) (*sql.Rows, error)
	ExecContext(ctx context.Context, sql string, args ...interface{}) (sql.Result, error)
	PrepareContext(ctx context.Context, sql string) (*sql.Stmt, error)
	IsOnMaster() bool
	IsTransaction() bool
}

Link 是一个常见的数据库函数包装接口。 注意，使用 `Link` 进行的任何操作都不会有 SQL 日志记录。 md5:d84360a9ae77a1de

type LocalType 

type LocalType string
const (
	LocalTypeUndefined   LocalType = ""
	LocalTypeString      LocalType = "string"
	LocalTypeDate        LocalType = "date"
	LocalTypeDatetime    LocalType = "datetime"
	LocalTypeInt         LocalType = "int"
	LocalTypeUint        LocalType = "uint"
	LocalTypeInt64       LocalType = "int64"
	LocalTypeUint64      LocalType = "uint64"
	LocalTypeIntSlice    LocalType = "[]int"
	LocalTypeInt64Slice  LocalType = "[]int64"
	LocalTypeUint64Slice LocalType = "[]uint64"
	LocalTypeInt64Bytes  LocalType = "int64-bytes"
	LocalTypeUint64Bytes LocalType = "uint64-bytes"
	LocalTypeFloat32     LocalType = "float32"
	LocalTypeFloat64     LocalType = "float64"
	LocalTypeBytes       LocalType = "[]byte"
	LocalTypeBool        LocalType = "bool"
	LocalTypeJson        LocalType = "json"
	LocalTypeJsonb       LocalType = "jsonb"
)

type Map 

type Map = map[string]interface{} // Map是map[string]interface{}的别名，这是最常用的映射类型。 md5:d30ae3cb84b9285e

type Map数组 

type Map数组 = []Map // List 是映射数组的类型。 md5:a6dda10906f1d599

type Model 

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

Model是实现ORM DAO的核心结构体。 md5:7230072d015718fc

func (*Model) Hook 

func (m *Model) Hook(hook HookHandler) *Model

Hook 设置当前模型的钩子函数。 md5:a324f56d597fd873

func (*Model) Offset 

func (m *Model) Offset(offset int) *Model

Offset 设置模型的“OFFSET”语句。它只对某些数据库（如 SQLServer、PostgreSQL 等）有意义。 md5:5a99cab6ce558c69

func (*Model) OnConflict 

func (m *Model) OnConflict(onConflict ...interface{}) *Model

OnConflict在列冲突时设置主键或索引。对于MySQL驱动程序来说，这通常是不必要的。 md5:30314cb75360b0e6

func (*Model) SoftTime 

func (m *Model) SoftTime(option SoftTimeOption) *Model

SoftTime 设置 SoftTimeOption 以自定义 Model 的软时间功能。 md5:6c4368abcd89e6b0

func (*Model) Unscoped 

func (m *Model) Unscoped() *Model

Unscoped禁用插入、更新和删除操作的软时间特性。 md5:0fc4af29459bd61e

func (*Model) X事务 

func (m *Model) X事务(上下文 context.Context, 回调函数 func(上下文 context.Context, tx TX) error) (错误 error)

X事务 包装了使用函数 `f` 执行的事务逻辑。 如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。如果函数 `f` 返回 nil，它将提交事务并返回 nil。

注意，在函数 `f` 中不应手动提交或回滚事务，因为这些操作将由这个函数自动处理。 md5:8906440d4dbbef1f

func (*Model) X关联全部对象 

func (m *Model) X关联全部对象() *Model

X关联全部对象 启用对结构体中带有 "with" 标签的所有对象进行模型关联操作。 md5:83d3591315f0add0

func (*Model) X关联对象 

func (m *Model) X关联对象(关联结构体 ...interface{}) *Model

X关联对象 创建并返回一个基于给定对象元数据的 ORM 模型。它还为给定的 `object` 启用模型关联操作功能。 可以多次调用此函数，以向模型中添加一个或多个对象，并启用它们的模式关联操作功能。 例如，如果给出的结构体定义如下：

``` 

type User struct {
    gmeta.Meta `orm:"table:user"`
    Id         int           `json:"id"`
    Name       string        `json:"name"`
    UserDetail *UserDetail   `orm:"with:uid=id"`
    UserScores []*UserScores `orm:"with:uid=id"`
}

```

我们可以通过以下方式在 `UserDetail` 和 `UserScores` 属性上启用模型关联操作：

``` db.X关联对象(User{}.UserDetail).X关联对象(User{}.UserScores).Scan(xxx) ```

或者：

``` db.X关联对象(UserDetail{}).X关联对象(UserScores{}).Scan(xxx) ```

或者：

``` db.X关联对象(UserDetail{}, UserScores{}).Scan(xxx) ``` md5:c9498702475d54a9

func (*Model) X内连接 

func (m *Model) X内连接(表或子查询和连接条件 ...string) *Model

X内连接 在模型上执行 "INNER JOIN ... ON ..." 语句。 参数 `table` 可以是需要连接的表及其连接条件，同时也可包含别名名称。

例如： Model("user").X内连接("user_detail", "user_detail.uid=user.uid") Model("user", "u").X内连接("user_detail", "ud", "ud.uid=u.uid") Model("user", "u").X内连接("SELECT xxx FROM xxx","a", "a.uid=u.uid") md5:eda419ad685c559d

func (*Model) X内连接带比较运算符 

func (m *Model) X内连接带比较运算符(表名, 第一个字段, 比较运算符, 第二个字段 string) *Model

X内连接带比较运算符 执行 InnerJoin 操作。它指定了不同的字段和比较运算符。

例如： Model("user").X内连接带比较运算符("order", "id", "=", "user_id") Model("user").X内连接带比较运算符("order", "id", ">", "user_id") Model("user").X内连接带比较运算符("order", "id", "<", "user_id")

这段代码是在 Go 语言中定义了一个方法，用于在两个数据表之间执行内连接（InnerJoin），并允许用户指定连接的字段以及比较运算符。例如，`"user".X内连接带比较运算符("order", "id", "=", "user_id")` 表示连接 "user" 表和 "order" 表，通过 "id" 字段进行等号（=）匹配。其他示例展示了使用大于（>）和小于（<）运算符的情况。 md5:0499f4b5bbbc2016

func (*Model) X内连接相同字段 

func (m *Model) X内连接相同字段(表名, 相同字段名 string) *Model

X内连接相同字段 的行为类似于 InnerJoin，但它使用的是具有`相同字段名`的两个表进行连接。

例如： Model("order").X内连接相同字段("user", "user_id") Model("order").X内连接相同字段("product", "product_id") md5:bdc954b5bcb8a9c5

func (*Model) X分割 

func (m *Model) X分割(数量 int, 处理函数 ChunkHandler)

X分割 使用给定的 `size` 和 `handler` 函数来分块迭代查询结果。 md5:4c5d0d282b8e1fe4

func (*Model) X切换数据库 

func (m *Model) X切换数据库(数据库名 string) *Model

X切换数据库 设置当前操作的模式。 md5:723e31c5f24ff604

func (*Model) X创建组合条件 

func (m *Model) X创建组合条件() *WhereBuilder

X创建组合条件 创建并返回一个 WhereBuilder。请注意，X创建组合条件 是线程安全的。 md5:d2708a694ae36dfa

func (*Model) X删除 

func (m *Model) X删除(条件 ...interface{}) (结果 sql.Result, 错误 error)

X删除 执行针对模型的 "DELETE FROM ... " 语句。 可选参数 `where` 与 Model.Where 函数的参数相同， 请参考 Model.Where 查看详细用法。 md5:efc496574e0829d8

func (*Model) X原生SQL 

func (m *Model) X原生SQL(原生Sql string, 参数 ...interface{}) *Model

X原生SQL 将当前模型设置为原始SQL模型。 示例： 

db.X原生SQL("SELECT * FROM `user` WHERE `name` = ?", "john").Scan(&result)

参见 Core.X原生SQL。 md5:ced75308536ddfff

func (*Model) X取上下文对象 

func (m *Model) X取上下文对象() context.Context

X取上下文对象返回当前Model的上下文。 如果之前没有设置上下文，则返回`context.Background()`。 md5:48edd9b438a38523

func (*Model) X取主节点对象 

func (m *Model) X取主节点对象() *Model

X取主节点对象 在主节点上标记以下操作。 md5:86cff0c5fb8d6d5d

func (*Model) X取从节点对象 

func (m *Model) X取从节点对象() *Model

X取从节点对象 在 slave 节点上标记以下操作。 请注意，只有在配置了 slave 节点的情况下，此注释才有意义。 md5:3d6dbca5bafb9cdf

func (*Model) X取副本 

func (m *Model) X取副本() *Model

X取副本 创建并返回一个新的模型，它是当前模型的克隆。请注意，它使用深拷贝进行克隆。 md5:27e973f2f4fb42b3

func (*Model) X取所有字段名称 

func (m *Model) X取所有字段名称(字段前缀 ...string) string

X取所有字段名称 从表中检索并返回所有字段，以逗号分隔。 可选参数 `prefix` 指定每个字段的前缀，例如：X取所有字段名称("u.")。 md5:c76f2f45c8680a27

func (*Model) X取所有字段名称并排除 

func (m *Model) X取所有字段名称并排除(需要排除字段 string, 字段前缀 ...string) string

X取所有字段名称并排除 从表中获取并返回那些不在参数`fields`中的字段，这些字段通过逗号','连接。 参数`fields`指定了需要排除的字段。 可选参数`prefix`为每个字段指定前缀，例如：FieldsExStr("id", "u.")。 md5:57698a0c43f54ec9

func (*Model) X取表字段信息Map 

func (m *Model) X取表字段信息Map(表名称 string, schema ...string) (字段信息Map map[string]*TableField, 错误 error)

X取表字段信息Map 获取并返回当前模式下指定表的字段信息。

参见 DriverMysql.X取表字段信息Map。 md5:61e256ba53f813cb

func (*Model) X右连接 

func (m *Model) X右连接(表或子查询和连接条件 ...string) *Model

X右连接 执行 "RIGHT JOIN ... ON ..." 语句在模型上。 参数 `table` 可以是待连接的表及其连接条件， 也可以包含表的别名。

例如： Model("user").X右连接("user_detail", "user_detail.uid=user.uid") Model("user", "u").X右连接("user_detail", "ud", "ud.uid=u.uid") Model("user", "u").X右连接("SELECT xxx FROM xxx","a", "a.uid=u.uid") md5:dbab2528fb37c84e

func (*Model) X右连接带比较运算符 

func (m *Model) X右连接带比较运算符(表名, 第一个字段, 比较运算符, 第二个字段 string) *Model

X右连接带比较运算符 执行右连接操作。它指定了不同的字段和比较运算符。

例如： User("user").X右连接带比较运算符("order", "id", "=", "user_id") User("user").X右连接带比较运算符("order", "id", ">", "user_id") User("user").X右连接带比较运算符("order", "id", "<", "user_id")

这里，`X右连接带比较运算符` 是一个 Go 代码中的函数，用于在查询数据库时执行右连接操作，并且允许用户自定义连接的字段和比较操作。第一个参数是模型名（如 "user"），接下来的参数包括要连接的表名、字段名以及连接条件（等于、大于或小于）。 md5:563f2b0f155fc829

func (*Model) X右连接相同字段 

func (m *Model) X右连接相同字段(表名, 相同字段名 string) *Model

X右连接相同字段 执行右连接，但使用相同的字段名称连接两个表。

例如： Model("order").InnerJoinOnField("user", "user_id") Model("order").InnerJoinOnField("product", "product_id") md5:ac8281e2d383e3d6

func (*Model) X处理函数 

func (m *Model) X处理函数(处理函数 ...ModelHandler) *Model

X处理函数 calls each of `handlers` on current Model and returns a new Model. X处理函数 calls each of `handlers` on current Model and returns a new Model. ModelHandler 是一个处理给定 Model 并返回一个自定义修改后的新 Model 的函数。 md5:a02af46ff8fb2568

func (*Model) X多表去重查询 

func (m *Model) X多表去重查询(Model对象 ...*Model) *Model

X多表去重查询 为模型执行 "(SELECT xxx FROM xxx) UNION (SELECT xxx FROM xxx) ..." 语句。 md5:97431dccd533414e

func (*Model) X多表查询 

func (m *Model) X多表查询(Model对象 ...*Model) *Model

X多表查询 对模型执行 "(SELECT xxx FROM xxx) UNION ALL (SELECT xxx FROM xxx) ..." 语句。 md5:d112aec0d1929661

func (*Model) X字段保留过滤 

func (m *Model) X字段保留过滤(字段名或Map结构体 ...interface{}) *Model

`X字段保留过滤` 方法将 `fieldNamesOrMapStruct` 添加到模型的operation字段中，多个字段使用字符`,`连接。 参数 `fieldNamesOrMapStruct` 可以是字符串、映射（map）、*map、结构体或*结构体类型。

示例： X字段保留过滤("id", "name", "age") X字段保留过滤([]string{"id", "name", "age"}) X字段保留过滤(map[string]interface{}{"id":1, "name":"john", "age":18}) X字段保留过滤(User{ Id: 1, Name: "john", Age: 18}) md5:21db86fe96babad2

func (*Model) X字段保留过滤并带前缀 

func (m *Model) X字段保留过滤并带前缀(前缀或别名 string, 字段名或Map结构体 ...interface{}) *Model

X字段保留过滤并带前缀 作为 Fields 函数，但为每个字段添加额外的前缀。 md5:8a672048e8753526

func (*Model) X字段排除过滤 

func (m *Model) X字段排除过滤(字段名或Map结构体 ...interface{}) *Model

X字段排除过滤 将 `fieldNamesOrMapStruct` 追加到模型的操作排除字段中， 多个字段使用逗号 ',' 连接。 注意，此函数仅支持单表操作。 参数 `fieldNamesOrMapStruct` 可以是字符串类型、映射类型（map）、映射指针类型（*map）、结构体类型或结构体指针类型（*struct）。

参见 Fields。 md5:7b8ec243202549a8

func (*Model) X字段排除过滤并带前缀 

func (m *Model) X字段排除过滤并带前缀(前缀或别名 string, 字段名或Map结构体 ...interface{}) *Model

X字段排除过滤并带前缀 函数与 FieldsEx 功能相似，但在每个字段前添加额外的前缀。 md5:66ba7040b83e6e81

func (*Model) X字段追加平均值 

func (m *Model) X字段追加平均值(求平均值字段名称 string, 新字段别名 ...string) *Model

X字段追加平均值 将常用字段 `AVG(column)` 格式化并添加到模型的 select 字段中。 md5:0b09ffae1b0cbabe

func (*Model) X字段追加最大值 

func (m *Model) X字段追加最大值(最大值字段名称 string, 新字段别名 ...string) *Model

X字段追加最大值 格式化并追加常用的字段 `MAX(column)` 到模型的选择字段中。 md5:77150e433b0d44c4

func (*Model) X字段追加最小值 

func (m *Model) X字段追加最小值(最小值字段名称 string, 新字段别名 ...string) *Model

X字段追加最小值 格式化并追加常用的字段 `MIN(column)` 到模型的选择字段中。 md5:fd1204ad66608451

func (*Model) X字段追加求和 

func (m *Model) X字段追加求和(需要求和的字段名称 string, 新字段别名 ...string) *Model

X字段追加求和 将常用字段 `SUM(column)` 格式化后添加到模型的 select 字段中。 md5:938249bb2923fa1f

func (*Model) X字段追加计数 

func (m *Model) X字段追加计数(需要计数的字段名称 string, 新字段别名 ...string) *Model

X字段追加计数 将常用字段 `COUNT(column)` 格式化并添加到模型的 select 字段中。 md5:99439830c058a91f

func (*Model) X左连接 

func (m *Model) X左连接(表或子查询和连接条件 ...string) *Model

X左连接 在模型上执行 "LEFT JOIN ... ON ..." 语句。 参数 `table` 可以是连接的表及其连接条件，也可以包含其别名。

示例： Model("user").X左连接("user_detail", "user_detail.uid=user.uid") Model("user", "u").X左连接("user_detail", "ud", "ud.uid=u.uid") Model("user", "u").X左连接("SELECT xxx FROM xxx", "a", "a.uid=u.uid") md5:5f7464280da64004

func (*Model) X左连接带比较运算符 

func (m *Model) X左连接带比较运算符(表名, 第一个字段, 比较运算符, 第二个字段 string) *Model

X左连接带比较运算符 执行类似于 LeftJoin 的操作，但允许指定不同的字段和比较运算符。

例如： Model("user").X左连接带比较运算符("order", "id", "=", "user_id") Model("user").X左连接带比较运算符("order", "id", ">", "user_id") Model("user").X左连接带比较运算符("order", "id", "<", "user_id") md5:90ce0e2226eb4b30

func (*Model) X左连接相同字段 

func (m *Model) X左连接相同字段(表名, 相同字段名 string) *Model

X左连接相同字段 执行左连接，但使用两个表中的`相同字段名`进行连接。

例如： Model("order").X左连接相同字段("user", "user_id") Model("order").X左连接相同字段("product", "product_id") md5:5ace5bdef45c73d6

func (*Model) X底层Args 

func (m *Model) X底层Args(参数 ...interface{}) *Model

X底层Args 为模型操作设置自定义参数。 md5:6cf507acdf0e2401

func (*Model) X底层QuoteWord 

func (m *Model) X底层QuoteWord(s string) string

X底层QuoteWord 检查给定的字符串 `s` 是否为一个单词， 如果是，它将使用数据库的安全字符对 `s` 进行转义，并返回带引号的字符串；否则，返回原始字符串不做任何更改。

可以认为一个 `word` 表示列名。 md5:71291615d7bcffe0

func (*Model) X排序 

func (m *Model) X排序(字段名与排序方式 ...interface{}) *Model

X排序 设置模型的 "ORDER BY" 语句。

示例： X排序("id desc") X排序("id", "desc"). X排序("id desc,name asc") X排序("id desc").X排序("name asc") X排序(gdb.Raw("field(id, 3,1,2)")) md5:41ff2d0293c241c6

func (*Model) X排序ASC 

func (m *Model) X排序ASC(字段名称 string) *Model

X排序ASC 设置模型的“ORDER BY xxx ASC”语句。 md5:be417beb10c6b9c1

func (*Model) X排序Desc 

func (m *Model) X排序Desc(字段名称 string) *Model

X排序Desc 为模型设置 "ORDER BY xxx DESC" 语句。 md5:ae573bad83990472

func (*Model) X排序分组 

func (m *Model) X排序分组(分组名称 ...string) *Model

X排序分组 设置模型的“GROUP BY”语句。 md5:51d1d1d81a2ab77a

func (*Model) X排序随机 

func (m *Model) X排序随机() *Model

X排序随机 为模型设置 "ORDER BY RANDOM()" 语句。 md5:e0a71e8f00c3d926

func (*Model) X插入 

func (m *Model) X插入(值 ...interface{}) (结果 sql.Result, 错误 error)

X插入 为模型执行 "INSERT INTO ..." 语句。 可选参数 `data` 等同于 Model.Data 函数的参数，参见 Model.Data。 md5:9a6427cabf3ec194

func (*Model) X插入并取ID 

func (m *Model) X插入并取ID(值 ...interface{}) (最后插入ID int64, 错误 error)

X插入并取ID 执行插入操作，并返回自动生成的最后一个插入id。 md5:8d00b40a35fa48a5

func (*Model) X插入并更新已存在 

func (m *Model) X插入并更新已存在(值 ...interface{}) (结果 sql.Result, 错误 error)

X插入并更新已存在 执行 "INSERT INTO ... ON DUPLICATE KEY UPDATE..." 语句，针对指定的模型。 可选参数 `data` 与 Model.Data 函数的参数相同，请参阅 Model.Data。

如果保存的数据中包含主键或唯一索引，它将更新记录； 否则，它会向表中插入一条新记录。 md5:9d87bd779f8f5acd

func (*Model) X插入并替换已存在 

func (m *Model) X插入并替换已存在(值 ...interface{}) (结果 sql.Result, 错误 error)

X插入并替换已存在 执行 "REPLACE INTO ..." 语句用于模型。 可选参数 `data` 与 Model.Data 函数的参数相同， 请参阅 Model.Data。 md5:d5596c2470b6bcf4

func (*Model) X插入并跳过已存在 

func (m *Model) X插入并跳过已存在(值 ...interface{}) (结果 sql.Result, 错误 error)

X插入并跳过已存在 为模型执行 "INSERT IGNORE INTO..." 语句。 可选参数 `data` 和 Model.Data 函数的参数相同，详情请参考 Model.Data。 md5:d6d8007d779bd324

func (*Model) X是否存在字段 

func (m *Model) X是否存在字段(字段名称 string) (bool, error)

X是否存在字段 用于判断该字段是否存在于表中。 md5:e26ad0ecb292096b

func (*Model) X更新 

func (m *Model) X更新(数据或条件 ...interface{}) (结果 sql.Result, 错误 error)

X更新 为模型执行"UPDATE ... "语句。

如果提供了可选参数 `dataAndWhere`，则 dataAndWhere[0] 是更新的数据字段，dataAndWhere[1:] 被视为 WHERE 条件字段。同时参考 Model.Data 和 Model.Where 函数。 md5:06a16ce16f9da0c0

func (*Model) X更新减量 

func (m *Model) X更新减量(字段名称 string, 减量值 interface{}) (sql.Result, error)

X更新减量 函数通过给定的数量减小某一列的值。 参数 `amount` 可以是浮点数或整数类型。 md5:e9b9ca17fcd1d042

func (*Model) X更新增量 

func (m *Model) X更新增量(字段名称 string, 增量值 interface{}) (sql.Result, error)

X更新增量 函数通过给定的数量增加某列的值。 参数 `amount` 可以是浮点数或整数类型。 md5:31e7e26d28456940

func (*Model) X更新并取影响行数 

func (m *Model) X更新并取影响行数(数据或条件 ...interface{}) (影响行数 int64, 错误 error)

X更新并取影响行数 执行更新语句并返回受影响的行数。 md5:2f9b42bc238e70a4

func (*Model) X条件 

func (m *Model) X条件(条件 interface{}, 参数 ...interface{}) *Model

X条件 为构建器设置条件语句。参数 `where` 可以是 字符串/映射/gmap/切片/结构体/结构体指针等类型。注意，如果调用多次， 多个条件将使用 "AND" 连接成 WHERE 语句。 参见 WhereBuilder.X条件。 md5:d18e25934a430281

func (*Model) X条件NULL值 

func (m *Model) X条件NULL值(字段名 ...string) *Model

X条件NULL值构建`columns[0] IS NULL AND columns[1] IS NULL ...`语句。 参见WhereBuilder.X条件NULL值。 md5:af598d8379efcab6

func (*Model) X条件NULL值并带前缀 

func (m *Model) X条件NULL值并带前缀(字段前缀 string, 字段名 ...string) *Model

X条件NULL值并带前缀 用于构建 `prefix.columns[0] IS NULL AND prefix.columns[1] IS NULL ...` 的SQL语句。 参考 WhereBuilder.X条件NULL值并带前缀 方法。 md5:e66f4e8ba9e64abe

func (*Model) X条件不包含 

func (m *Model) X条件不包含(字段名 string, 不包含值 interface{}) *Model

X条件不包含构建`column NOT IN (in)`语句。 请参阅WhereBuilder.X条件不包含。 md5:4fbfcfa2b85a83d2

func (*Model) X条件不包含并带前缀 

func (m *Model) X条件不包含并带前缀(字段前缀 string, 字段名 string, 不包含值 interface{}) *Model

X条件不包含并带前缀 构建 `prefix.column NOT IN (in)` 语句。 参考 WhereBuilder.X条件不包含并带前缀。 md5:ae3cd87814389feb

func (*Model) X条件不等于 

func (m *Model) X条件不等于(字段名 string, 值 interface{}) *Model

X条件不等于构建`column != value`语句。 参见WhereBuilder.X条件不等于。 md5:973b26be7332c7b2

func (*Model) X条件不等于并带前缀 

func (m *Model) X条件不等于并带前缀(字段前缀 string, 字段名 string, 值 interface{}) *Model

X条件不等于并带前缀 构建 `prefix.column != value` 的语句。 参见 WhereBuilder.X条件不等于并带前缀 的用法。 md5:52ce1c05f4e382fb

func (*Model) X条件包含 

func (m *Model) X条件包含(字段名 string, 包含值 interface{}) *Model

X条件包含 构建 `column IN (in)` 语句。 参考 WhereBuilder.X条件包含。 md5:b4b77eb17cf9b671

func (*Model) X条件包含并带前缀 

func (m *Model) X条件包含并带前缀(字段前缀 string, 字段名 string, 包含值 interface{}) *Model

X条件包含并带前缀 构建 `prefix.column IN (in)` 语句。 参见 WhereBuilder.X条件包含并带前缀。 md5:21e5a1f77d32a6ce

func (*Model) X条件取范围 

func (m *Model) X条件取范围(字段名 string, 最小值, 最大值 interface{}) *Model

X条件取范围 用于构建 `column BETWEEN min AND max` 的语句。 参见 WhereBuilder.X条件取范围 的使用。 md5:88a499f60e180ae2

func (*Model) X条件取范围以外 

func (m *Model) X条件取范围以外(字段名 string, 最小值, 最大值 interface{}) *Model

X条件取范围以外 用于构建 `column NOT BETWEEN min AND max` 的SQL语句。 参见WhereBuilder.X条件取范围以外的用法。 md5:be0e739db028ee79

func (*Model) X条件取范围以外并带前缀 

func (m *Model) X条件取范围以外并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *Model

X条件取范围以外并带前缀构建`prefix.column NOT BETWEEN min AND max`语句。 参见WhereBuilder.X条件取范围以外并带前缀。 md5:2cfa2b60438f51a2

func (*Model) X条件取范围并带前缀 

func (m *Model) X条件取范围并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *Model

X条件取范围并带前缀构建`prefix.column BETWEEN min AND max`语句。 参见WhereBuilder.X条件取范围并带前缀。 md5:5bd292414bb58ab2

func (*Model) X条件大于 

func (m *Model) X条件大于(字段名 string, 比较值 interface{}) *Model

X条件大于构建`column > value`语句。 参见WhereBuilder.X条件大于。 md5:900e4d7769d650c2

func (*Model) X条件大于并带前缀 

func (m *Model) X条件大于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件大于并带前缀 构建 `prefix.column > value` 的语句。 参见 WhereBuilder.X条件大于并带前缀 的用法。 md5:7bd6fca29c275204

func (*Model) X条件大于等于 

func (m *Model) X条件大于等于(字段名 string, 比较值 interface{}) *Model

X条件大于等于构建`column >= value`语句。 参见WhereBuilder.X条件大于等于。 md5:cd051232a4d3707c

func (*Model) X条件大于等于并带前缀 

func (m *Model) X条件大于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件大于等于并带前缀 构建 `prefix.column >= value` 语句。 参见 WhereBuilder.X条件大于等于并带前缀。 md5:f4256046c4ee0127

func (*Model) X条件小于 

func (m *Model) X条件小于(字段名 string, 比较值 interface{}) *Model

X条件小于 用于构建 `column < value` 的语句。 参见 WhereBuilder.X条件小于。 md5:16aa57cc63797f44

func (*Model) X条件小于并带前缀 

func (m *Model) X条件小于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件小于并带前缀构建`prefix.column < value`语句。 参考WhereBuilder.X条件小于并带前缀。 md5:772fb94f7bcccb22

func (*Model) X条件小于等于 

func (m *Model) X条件小于等于(字段名 string, 比较值 interface{}) *Model

X条件小于等于 构建 `column <= value` 条件语句。 参考 WhereBuilder.X条件小于等于。 md5:85440b32a52d1c2c

func (*Model) X条件小于等于并带前缀 

func (m *Model) X条件小于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件小于等于并带前缀构建`prefix.column <= value`语句。 参见WhereBuilder.X条件小于等于并带前缀。 md5:09fe8d74131bca96

func (*Model) X条件带前缀 

func (m *Model) X条件带前缀(字段前缀 string, 条件 interface{}, 参数 ...interface{}) *Model

X条件带前缀 的行为与 Where 相似，但它会为 where 语句中的每个字段添加前缀。 参考 WhereBuilder.X条件带前缀。 md5:857520a0e9f2f42c

func (*Model) X条件并识别主键 

func (m *Model) X条件并识别主键(条件 interface{}, 参数 ...interface{}) *Model

X条件并识别主键 的逻辑与 Model.Where 相同，但当参数 `where` 是一个单一的条件，如 int、string、float 或 slice 时，它会将条件视为主键值。也就是说，如果主键是 "id"，并且给定的 `where` 参数为 "123"，X条件并识别主键 函数会将条件解析为 "id=123"，而 Model.Where 则会将条件视为字符串 "123"。 参阅 WhereBuilder.X条件并识别主键。 md5:13dc66b105f841e9

func (*Model) X条件或 

func (m *Model) X条件或(条件 interface{}, 参数 ...interface{}) *Model

X条件或在where语句中添加"OR"条件。请参考WhereBuilder.X条件或。 md5:3dc9824669296cea

func (*Model) X条件或NULL值 

func (m *Model) X条件或NULL值(字段名 ...string) *Model

X条件或NULL值 构建 `columns[0] IS NULL OR columns[1] IS NULL ...` 的 `OR` 条件语句。 参考 WhereBuilder.X条件或NULL值。 md5:66907cf860f22eff

func (*Model) X条件或NULL值并带前缀 

func (m *Model) X条件或NULL值并带前缀(字段前缀 string, 字段名 ...string) *Model

X条件或NULL值并带前缀 用于在`OR`条件中构建 `prefix.columns[0] IS NULL OR prefix.columns[1] IS NULL ...` 的语句。 参考 WhereBuilder.X条件或NULL值并带前缀。 md5:526f8d0f44781d5f

func (*Model) X条件或不包含 

func (m *Model) X条件或不包含(字段名 string, 不包含值 interface{}) *Model

X条件或不包含构建`column NOT IN (in)`语句。 参见WhereBuilder.X条件或不包含。 md5:22915d1ba70db001

func (*Model) X条件或不包含并带前缀 

func (m *Model) X条件或不包含并带前缀(字段前缀 string, 字段名 string, 不包含值 interface{}) *Model

X条件或不包含并带前缀 用于构建 `prefix.column NOT IN (in)` 的SQL语句。 参见WhereBuilder中的X条件或不包含并带前缀方法。 md5:890322e319ab2ff8

func (*Model) X条件或不等于 

func (m *Model) X条件或不等于(字段名 string, 值 interface{}) *Model

X条件或不等于构建`column != value`语句。 参见WhereBuilder.X条件或不等于。 md5:076a864671142e49

func (*Model) X条件或不等于并带前缀 

func (m *Model) X条件或不等于并带前缀(字段前缀 string, 字段名 string, 值 interface{}) *Model

X条件或不等于并带前缀在`OR`条件下构建`prefix.column != value`语句。请参阅WhereBuilder.X条件或不等于并带前缀。 md5:46f5833fb4aa8a66

func (*Model) X条件或包含 

func (m *Model) X条件或包含(字段名 string, 包含值 interface{}) *Model

X条件或包含在`OR`条件下构建`column IN (in)`语句。参见WhereBuilder.X条件或包含。 md5:fac500879081e3cc

func (*Model) X条件或包含并带前缀 

func (m *Model) X条件或包含并带前缀(字段前缀 string, 字段名 string, 包含值 interface{}) *Model

X条件或包含并带前缀 用于构建 `OR` 条件下的 `prefix.column IN (in)` 语句。 参见 WhereBuilder.X条件或包含并带前缀 的用法。 md5:16a0a007f82dbf8e

func (*Model) X条件或取范围 

func (m *Model) X条件或取范围(字段名 string, 最小值, 最大值 interface{}) *Model

X条件或取范围 构建在 `OR` 条件下的 `column BETWEEN min AND max` 语句。 参见 WhereBuilder.X条件或取范围 的用法。 md5:c9b005a18a1fb87e

func (*Model) X条件或取范围以外 

func (m *Model) X条件或取范围以外(字段名 string, 最小值, 最大值 interface{}) *Model

X条件或取范围以外 用于构建 `column NOT BETWEEN min AND max` 的 SQL 语句，在 `OR` 条件下。 参见 WhereBuilder.X条件或取范围以外 的用法。 md5:e040a9f04b492725

func (*Model) X条件或取范围以外并带前缀 

func (m *Model) X条件或取范围以外并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *Model

X条件或取范围以外并带前缀 在 `OR` 条件下构建 `prefix.column NOT BETWEEN min AND max` 语句。 参考 WhereBuilder.X条件或取范围以外并带前缀。 md5:a2c385cd5a8a13f7

func (*Model) X条件或取范围并带前缀 

func (m *Model) X条件或取范围并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *Model

X条件或取范围并带前缀在`OR`条件下构建`prefix.column BETWEEN min AND max`语句。请参考WhereBuilder.X条件或取范围并带前缀。 md5:bcd63a0bb32b253d

func (*Model) X条件或大于 

func (m *Model) X条件或大于(字段名 string, 比较值 interface{}) *Model

X条件或大于在`OR`条件下构建`column > value`语句。请参阅WhereBuilder.X条件或大于。 md5:5b5f0de728017e9e

func (*Model) X条件或大于并带前缀 

func (m *Model) X条件或大于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件或大于并带前缀 构建在 `OR` 条件下的 `prefix.column > value` 语句。 参见 WhereBuilder.X条件或大于并带前缀 的用法。 md5:c2ab1e36dc3d561b

func (*Model) X条件或大于等于 

func (m *Model) X条件或大于等于(字段名 string, 比较值 interface{}) *Model

X条件或大于等于在`OR`条件下构建`column >= value`语句。 参见WhereBuilder.X条件或大于等于。 md5:5e6ab2d7c60899f4

func (*Model) X条件或大于等于并带前缀 

func (m *Model) X条件或大于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件或大于等于并带前缀 在 OR 条件中构建 `prefix.column >= value` 语句。 参考 WhereBuilder.X条件或大于等于并带前缀。 md5:a3ee1fcd237d45d6

func (*Model) X条件或小于 

func (m *Model) X条件或小于(字段名 string, 比较值 interface{}) *Model

X条件或小于 在 `OR` 条件下构建 `column < value` 语句。 参见 WhereBuilder.X条件或小于。 md5:d9d4ee2080c8c040

func (*Model) X条件或小于并带前缀 

func (m *Model) X条件或小于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件或小于并带前缀在"OR"条件下构建`prefix.column < value`语句。参阅WhereBuilder.X条件或小于并带前缀。 md5:0a8c07ff239fa7e7

func (*Model) X条件或小于等于 

func (m *Model) X条件或小于等于(字段名 string, 比较值 interface{}) *Model

X条件或小于等于 在`OR`条件中构建 `column <= value` 的语句。 参考 WhereBuilder.X条件或小于等于。 md5:36414de9c787b690

func (*Model) X条件或小于等于并带前缀 

func (m *Model) X条件或小于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *Model

X条件或小于等于并带前缀 在 "OR" 条件下构建 `prefix.column <= value` 语句。 参见 WhereBuilder.X条件或小于等于并带前缀。 md5:5c67992d7a2d9176

func (*Model) X条件或并带前缀 

func (m *Model) X条件或并带前缀(字段前缀 string, 条件 interface{}, 参数 ...interface{}) *Model

X条件或并带前缀 的行为与 WhereOr 相似，但它会在where语句中的每个字段前添加前缀。 参考 WhereBuilder.X条件或并带前缀。 md5:4ea5d18d5615ff17

func (*Model) X条件或格式化 

func (m *Model) X条件或格式化(格式 string, 参数 ...interface{}) *Model

X条件或格式化 使用 fmt.Sprintf 和参数构建 `OR` 条件字符串。 参见 WhereBuilder.X条件或格式化。 md5:a94c42c383ac4960

func (*Model) X条件或模糊匹配 

func (m *Model) X条件或模糊匹配(字段名 string, 通配符条件值 interface{}) *Model

X条件或模糊匹配 在`OR`条件中构建 `column LIKE like` 语句。 参考 WhereBuilder.X条件或模糊匹配。 md5:70c0895d15fd2cc9

func (*Model) X条件或模糊匹配以外 

func (m *Model) X条件或模糊匹配以外(字段名 string, 通配符条件值 interface{}) *Model

X条件或模糊匹配以外 用于构建在`OR`条件下的 `column NOT LIKE 'like'` 语句。 参考 WhereBuilder.X条件或模糊匹配以外。 md5:588ea3675853468b

func (*Model) X条件或模糊匹配以外并带前缀 

func (m *Model) X条件或模糊匹配以外并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *Model

X条件或模糊匹配以外并带前缀 在 `OR` 条件下构建 `prefix.column NOT LIKE like` 语句。 参见 WhereBuilder.X条件或模糊匹配以外并带前缀。 md5:2c4e846be65e70c1

func (*Model) X条件或模糊匹配并带前缀 

func (m *Model) X条件或模糊匹配并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *Model

X条件或模糊匹配并带前缀构建了`prefix.column LIKE like`条件下的`OR`语句。请参考WhereBuilder.X条件或模糊匹配并带前缀。 md5:42d57b9f251b31f3

func (*Model) X条件或非Null 

func (m *Model) X条件或非Null(字段名 ...string) *Model

X条件或非Null 构建在 `OR` 条件下的 `columns[0] IS NOT NULL OR columns[1] IS NOT NULL ...` 语句。 参见 WhereBuilder.X条件或非Null 的用法。 md5:5645594c534afc8e

func (*Model) X条件或非Null并带前缀 

func (m *Model) X条件或非Null并带前缀(字段前缀 string, 字段名 ...string) *Model

X条件或非Null并带前缀 在 `OR` 条件中构建 `prefix.columns[0] IS NOT NULL OR prefix.columns[1] IS NOT NULL ...` 语句。 参考 WhereBuilder.X条件或非Null并带前缀。 md5:537c634be4bd78f3

func (*Model) X条件格式化 

func (m *Model) X条件格式化(格式 string, 参数 ...interface{}) *Model

X条件格式化 使用 fmt.Sprintf 和参数构建条件字符串。 注意，如果 `args` 的数量多于 `format` 中的占位符， 多余的 `args` 将用作 Model 的 WHERE 条件参数。 参见 WhereBuilder.X条件格式化。 md5:ecb69c9051fee97d

func (*Model) X条件模糊匹配 

func (m *Model) X条件模糊匹配(字段名 string, 通配符条件值 string) *Model

X条件模糊匹配 构建 `column LIKE like` 语句。 参考 WhereBuilder.X条件模糊匹配。 md5:0d0b14277dfc3be8

func (*Model) X条件模糊匹配以外 

func (m *Model) X条件模糊匹配以外(字段名 string, 通配符条件值 interface{}) *Model

X条件模糊匹配以外 构建 `column NOT LIKE like` 语句。 参考 WhereBuilder.X条件模糊匹配以外。 md5:1be6fd9ae98cc213

func (*Model) X条件模糊匹配以外并带前缀 

func (m *Model) X条件模糊匹配以外并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *Model

X条件模糊匹配以外并带前缀构建`prefix.column NOT LIKE like`语句。 参见WhereBuilder.X条件模糊匹配以外并带前缀。 md5:a9a2f0b1ba94005b

func (*Model) X条件模糊匹配并带前缀 

func (m *Model) X条件模糊匹配并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *Model

X条件模糊匹配并带前缀构建`prefix.column LIKE like`语句。 请参考WhereBuilder.X条件模糊匹配并带前缀。 md5:52c7b5d6907728da

func (*Model) X条件非Null 

func (m *Model) X条件非Null(字段名 ...string) *Model

X条件非Null 构建 `columns[0] IS NOT NULL AND columns[1] IS NOT NULL ...` 语句。 参见 WhereBuilder.X条件非Null 的用法。 md5:05b9b4179d41a28b

func (*Model) X条件非Null并带前缀 

func (m *Model) X条件非Null并带前缀(字段前缀 string, 字段名 ...string) *Model

X条件非Null并带前缀 构建 `prefix.columns[0] IS NOT NULL AND prefix.columns[1] IS NOT NULL ...` 语句。 参见 WhereBuilder.X条件非Null并带前缀。 md5:953102e755997338

func (*Model) X查询 

func (m *Model) X查询(查询条件 ...interface{}) (Result, error)

所有执行的是 "FROM ..." 语句针对该模型。 它从表中检索记录，并将结果作为切片类型返回。 如果根据给定条件从表中没有检索到任何记录，它将返回nil。

可选参数 `where` 和 Model.Where 函数的参数相同， 请参阅 Model.Where。 md5:fd88d2addfbe9655

func (*Model) X查询一条 

func (m *Model) X查询一条(条件 ...interface{}) (Record, error)

从表中获取一条记录，并将结果作为map类型返回。如果使用给定条件从表中没有检索到记录，则返回nil。

可选参数`where`与Model.Where函数的参数相同，参见Model.Where。 md5:b48f8e0c5d07b484

func (*Model) X查询一条值 

func (m *Model) X查询一条值(字段和条件 ...interface{}) (Value, error)

X查询一条值 从表中获取指定记录的值，并将结果作为接口类型返回。 如果根据给定条件在表中找不到记录，它将返回nil。

如果提供了可选参数 `fieldsAndWhere`，其中 fieldsAndWhere[0] 是选择的字段， 而 fieldsAndWhere[1:] 用作 WHERE 条件字段。 另请参阅 Model.Fields 和 Model.Where 函数。 md5:e6b48ca188d3d208

func (*Model) X查询与行数 

func (m *Model) X查询与行数(是否用字段计数 bool) (结果 Result, 行数 int, 错误 error)

X查询与行数 从模型中检索所有记录以及记录的总数量。 如果 useFieldForCount 为真，它将使用模型中指定的字段进行计数； 否则，它将使用常数值1来进行计数。 此方法返回结果作为一个记录切片，记录的总数量，以及可能存在的错误。 where 参数是一个可选的条件列表，用于在检索记录时应用。

示例： 

var model Model
var result []Record
var count int
where := []interface{}{"name = ?", "John"}
result, count, err := model.X查询与行数(true, where...)
if err != nil {
    // 处理错误。
}
fmt.Println(result, count)

md5:b631bbec9e186f68

func (*Model) X查询与行数到指针 

func (m *Model) X查询与行数到指针(数据指针 interface{}, 行数指针 *int, 是否用字段计数 bool) (错误 error)

X查询与行数到指针 扫描与给定条件匹配的单条记录或记录数组，并计算符合这些条件的总记录数。 如果 useFieldForCount 为 true，它将使用模型中指定的字段进行计数； pointer 参数是一个指向结构体的指针，用于存储扫描到的数据。 pointerCount 参数是一个指向整数的指针，将被设置为符合给定条件的总记录数。 where 参数是可选的条件列表，用于在检索记录时使用。

示例： 

var count int
user := new(User)
err  := db.Model("user").Where("id", 1).X查询与行数到指针(user, &count, true)
fmt.Println(user, count)

示例（联接）： 

type User struct {
	Id       int
	Passport string
	Name     string
	Age      int
}
var users []User
var count int
db.Model(table).As("u1").
	LeftJoin(tableName2, "u2", "u2.id=u1.id").
	Fields("u1.passport,u1.id,u2.name,u2.age").
	Where("u1.id<2").
	X查询与行数到指针(&users, &count, false)

md5:984fa8f0e50708f4

func (*Model) X查询到指针列表 

func (m *Model) X查询到指针列表(结构体数组指针 interface{}, 绑定到结构体属性名称 string, 结构体属性关联 ...string) (错误 error)

X查询到指针列表 将 `r` 转换为包含其他复杂结构体属性的切片。请注意，参数 `listPointer` 的类型应该是 `*[]struct` 或 `*[]*struct`。

参见 Result.X查询到指针列表。 md5:4116492a123661b5

func (*Model) X查询到结构体指针 

func (m *Model) X查询到结构体指针(数据指针 interface{}, 条件 ...interface{}) error

X查询到结构体指针会根据参数`pointer`的类型自动调用Struct或Structs函数。 如果`pointer`是类型`*struct`或`**struct`，它会调用doStruct函数。 如果`pointer`是类型`*[]struct`或`*[]*struct`，它会调用doStructs函数。

可选参数`where`与Model.Where函数的参数相同，参见Model.Where。

注意，如果给定的`pointer`指向一个具有默认值的变量，并且在表中没有满足条件的记录，它将返回sql.ErrNoRows错误。

示例： user := new(User) err := db.Model("user").Where("id", 1).X查询到结构体指针(user)

user := (*User)(nil) err := db.Model("user").Where("id", 1).X查询到结构体指针(&user)

users := ([]User)(nil) err := db.Model("user").X查询到结构体指针(&users)

users := ([]*User)(nil) err := db.Model("user").X查询到结构体指针(&users) md5:a6df07ddafe5975a

func (*Model) X查询字段行数 

func (m *Model) X查询字段行数(字段名称 string) (int, error)

X查询字段行数 执行对模型的 "SELECT COUNT(x) FROM ..." 语句。 md5:150abf4737c4588c

func (*Model) X查询平均值 

func (m *Model) X查询平均值(字段名称 string) (float64, error)

X查询平均值 对于该模型执行"SELECT AVG(x) FROM ..." 语句。 md5:9b360a11d26d6fca

func (*Model) X查询数组 

func (m *Model) X查询数组(条件 ...interface{}) ([]Value, error)

从数据库查询并返回数据值作为切片。 注意，如果结果中有多个列，它会随机返回一列的值。

如果提供了可选参数 `fieldsAndWhere`，则 fieldsAndWhere[0] 是选择的字段， 而 fieldsAndWhere[1:] 则被视为 where 条件字段。 参见 Model.Fields 和 Model.Where 函数。 md5:1de6885dc1e83172

func (*Model) X查询最大值 

func (m *Model) X查询最大值(字段名称 string) (float64, error)

X查询最大值 对模型执行 "SELECT MAX(x) FROM ..." 语句。 md5:bb6b4d0dc51fbfaf

func (*Model) X查询最小值 

func (m *Model) X查询最小值(字段名称 string) (float64, error)

X查询最小值 为模型执行 "SELECT MIN(x) FROM ..." 语句。 md5:e2fc098c542503d1

func (*Model) X查询求和 

func (m *Model) X查询求和(字段名称 string) (float64, error)

X查询求和 对于该模型执行 "SELECT SUM(x) FROM ..." 语句。 md5:bcbe9e29cd168603

func (*Model) X查询行数 

func (m *Model) X查询行数(条件 ...interface{}) (int, error)

X查询行数 对于该模型执行 "SELECT COUNT(x) FROM ..." 语句。 可选参数 `where` 和 Model.Where 函数的参数相同，参见 Model.Where。 md5:52b3d2e0e43bb2af

func (*Model) X缓存 

func (m *Model) X缓存(选项 CacheOption) *Model

X缓存 为模型设置缓存功能。它将 SQL 的结果缓存起来，这意味着如果有相同的 SQL 请求， 它会直接从缓存中读取并返回结果，而不会真正提交并执行到数据库中。

注意，如果模型在事务中执行 SELECT 语句，缓存功能将被禁用。 md5:5d7ea513a485f3ad

func (*Model) X设置DB对象 

func (m *Model) X设置DB对象(DB对象 DB) *Model

X设置DB对象 为当前操作设置或更改 db 对象。 md5:1761cc3b00f1d6bb

func (*Model) X设置上下文并取副本 

func (m *Model) X设置上下文并取副本(上下文 context.Context) *Model

X设置上下文并取副本 设置当前操作的上下文。 md5:77d589f34a65753b

func (*Model) X设置事务对象 

func (m *Model) X设置事务对象(事务对象 TX) *Model

X设置事务对象 设置或更改当前操作的事务。 md5:7171a26d8d2d8431

func (*Model) X设置分区名称 

func (m *Model) X设置分区名称(分区名称 ...string) *Model

分区设置分区名称。 例子： dao.User.Ctx(ctx).X设置分区名称("p1", "p2", "p3").All()

这段Go代码的注释表示：使用`X设置分区名称`方法对数据进行分区操作，传入多个分区名称（如："p1", "p2", "p3"），然后在查询时指定这些分区。`Ctx(ctx)`表示使用上下文`ctx`进行操作。`All()`是获取所有满足条件的数据。 md5:f133a577ba31c05f

func (*Model) X设置分组条件 

func (m *Model) X设置分组条件(条件 interface{}, 参数 ...interface{}) *Model

X设置分组条件 设置模型的having语句。 该函数的使用参数与Where函数相同。 参见Where。 md5:b4e737511765f79f

func (*Model) X设置分页 

func (m *Model) X设置分页(第几页, 条数 int) *Model

X设置分页 设置模型的分页号。 参数 `page` 的起始值为1，用于分页。 注意，这与Limit函数在"LIMIT"语句中从0开始不同。 md5:02b920e99951ce53

func (*Model) X设置去重 

func (m *Model) X设置去重() *Model

X设置去重 强制查询仅返回不重复的结果。 md5:ead62c0e4b4795ab

func (*Model) X设置批量操作行数 

func (m *Model) X设置批量操作行数(数量 int) *Model

X设置批量操作行数 为模型设置批处理操作的数量。 md5:7ae8528d1f8ac604

func (*Model) X设置插入冲突不更新字段 

func (m *Model) X设置插入冲突不更新字段(字段名称 ...interface{}) *Model

X设置插入冲突不更新字段 设置在发生列冲突时排除的列，用于操作。 在 MySQL 中，这用于 "ON DUPLICATE KEY UPDATE" 语句。 在 PgSQL 中，这用于 "ON CONFLICT (id) DO UPDATE SET" 语句。 参数 `onDuplicateEx` 可以是字符串、映射或切片类型。 示例：

X设置插入冲突不更新字段("passport, password") X设置插入冲突不更新字段("passport", "password") 

X设置插入冲突不更新字段(g.Map{
	  "passport": "",
	  "password": "",
})

md5:6fa8981bef042b71

func (*Model) X设置插入冲突更新字段 

func (m *Model) X设置插入冲突更新字段(字段名称 ...interface{}) *Model

X设置插入冲突更新字段 设置在列发生冲突时执行的操作。 在MySQL中，这用于 "ON DUPLICATE KEY UPDATE" 语句。 在PgSQL中，这用于 "ON CONFLICT (id) DO UPDATE SET" 语句。 参数 `onDuplicate` 可以是字符串/Raw/*Raw/映射/切片类型。 示例：

X设置插入冲突更新字段("nickname, age") X设置插入冲突更新字段("nickname", "age") 

X设置插入冲突更新字段(g.Map{
	  "nickname": gdb.Raw("CONCAT('name_', VALUES(`nickname`))"),
})

X设置插入冲突更新字段(g.Map{
	  "nickname": "passport",
})

md5:fa9214f9681b4e5d

func (*Model) X设置数据 

func (m *Model) X设置数据(值 ...interface{}) *Model

X设置数据 设置模型的操作数据。 参数 `data` 可以为字符串/映射/gmap/切片/结构体/**结构体指针**等类型。 注意，如果`data`是映射或切片类型，它将使用浅复制以避免在函数内部改变原数据。 例如： X设置数据("uid=10000") X设置数据("uid", 10000) X设置数据("uid=? AND name=?", 10000, "john") X设置数据(g.Map{"uid": 10000, "name":"john"}) X设置数据(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"}}) md5:116cf94880dfa535

func (*Model) X设置条数 

func (m *Model) X设置条数(条数或两个数字 ...int) *Model

X设置条数 设置模型的 "LIMIT" 语句。 参数 `limit` 可以是一个或两个数字。如果传递两个数字，它将为模型设置 "LIMIT limit[0],limit[1]" 语句；否则，它将设置 "LIMIT limit[0]" 语句。 md5:fd06ed75a128d403

func (*Model) X设置表别名 

func (m *Model) X设置表别名(别名 string) *Model

X设置表别名 设置当前表的别名名称。 md5:c28e3f79c6fe2e48

func (*Model) X过滤Nil 

func (m *Model) X过滤Nil() *Model

X过滤Nil为模型设置optionOmitNil选项，该选项会自动过滤掉`nil`值的数据和where参数。 md5:d24d4fb4b4f59068

func (*Model) X过滤Nil数据 

func (m *Model) X过滤Nil数据() *Model

X过滤Nil数据 为模型设置 optionOmitNilData 选项，该选项会自动过滤掉 Data 参数中的 `nil` 值。 md5:e6503d524a0d8d31

func (*Model) X过滤Nil条件 

func (m *Model) X过滤Nil条件() *Model

X过滤Nil条件 为模型设置了 optionOmitNilWhere 选项，该选项会自动过滤掉 Where/Having 参数中的 `nil` 值。 md5:b5927ba5d926adaf

func (*Model) X过滤空值 

func (m *Model) X过滤空值() *Model

X过滤空值 为模型设置了 optionOmitEmpty 选项，该选项会自动过滤掉 数据和 where 参数中的 `空值`。 md5:bf1dc800704b3324

func (*Model) X过滤空值数据 

func (m *Model) X过滤空值数据() *Model

X过滤空值数据 为模型设置 optionOmitEmptyData 选项，该选项会自动过滤掉 Data 参数中的空值。 md5:56dab615155b1550

func (*Model) X过滤空值条件 

func (m *Model) X过滤空值条件() *Model

X过滤空值条件 为模型设置 optionOmitEmptyWhere 选项，该选项会自动过滤掉 Where/Having 参数中的"空"值。

示例： 

Where("id", []int{}).All()             -> SELECT xxx FROM xxx WHERE 0=1
Where("name", "").All()                -> SELECT xxx FROM xxx WHERE `name`=''
OmitEmpty().Where("id", []int{}).All() -> SELECT xxx FROM xxx
OmitEmpty().("name", "").All()         -> SELECT xxx FROM xxx.

md5:df62f4199a96c566

func (*Model) X链式安全 

func (m *Model) X链式安全(开启 ...bool) *Model

X链式安全 标记此模型为安全或不安全。如果 safe 为 true，那么在执行完操作后，它会克隆并返回一个新的模型对象； 否则，它将直接修改当前模型的属性。 md5:56aecad30556ca98

func (*Model) X锁写入 

func (m *Model) X锁写入() *Model

X锁写入 将当前操作的锁设置为共享模式。 md5:d3afc426055403b9

func (*Model) X锁读写 

func (m *Model) X锁读写() *Model

X锁读写 为当前操作设置更新锁。 md5:ecffaffee1e7b1df

type ModelHandler 

type ModelHandler func(m *Model) *Model

Handler calls each of `handlers` on current Model and returns a new Model. ModelHandler 是一个处理给定 Model 并返回一个自定义修改后的新 Model 的函数。 md5:a02af46ff8fb2568

type Raw 

type Raw string // Raw是一个原始SQL，它不会被当作参数对待，而是直接作为SQL的一部分。 md5:cd876e2c863a974f

type Record 

type Record map[string]Value // Record 是表格的行记录。 md5:f13ea17db2caaf51

func (Record) X取Map 

func (r Record) X取Map() Map

X取Map 将 `r` 转换为 map[string]interface{} 类型。 md5:5b4502a5f29602f9

func (Record) X取Map类 

func (r Record) X取Map类() *gmap.StrAnyMap

X取Map类将`r`转换为gmap。 md5:573ff0b484a9573f

func (Record) X取json 

func (r Record) X取json() string

X取json 将 `r` 转换为JSON格式的内容。 md5:60a0626b0a333d14

func (Record) X取xml 

func (r Record) X取xml(根标记 ...string) string

X取xml 将 `r` 转换为 XML 格式的内容。 md5:31a335fedb874d26

func (Record) X取结构体指针 

func (r Record) X取结构体指针(结构体指针 interface{}) error

X取结构体指针 将 `r` 转换为结构体。 注意参数 `pointer` 应为 *struct 或 **struct 类型。

注意，如果 `r` 为空，它将返回 sql.ErrNoRows。 md5:9ad6d688dbdddb25

func (Record) X是否为空 

func (r Record) X是否为空() bool

X是否为空 检查 `r` 是否为空，然后返回结果。 md5:4ee28a47e769cceb

type Result 

type Result []Record // Result 是行记录数组。 md5:cfc50f7c3d051e4e

func (Result) RecordKeyInt 

func (r Result) RecordKeyInt(key string) map[int]Record

RecordKeyInt 将 `r` 转换为一个映射[int]Record，其中键由 `key` 指定。 md5:0ebe0554d495cbae

func (Result) RecordKeyStr 

func (r Result) RecordKeyStr(key string) map[string]Record

RecordKeyStr 将 `r` 转换为一个 map[string]Record，其中的键由 `key` 指定。 md5:6eaa1193e5507d8a

func (Result) RecordKeyUint 

func (r Result) RecordKeyUint(key string) map[uint]Record

RecordKeyUint 将 `r` 转换为一个以指定的 `key` 作为键的 [uint]Record 映射。 md5:26ce469215f5d9c2

func (Result) Size别名 

func (r Result) Size别名() int

Size别名 是函数 Len 的别名。 md5:4cfc93cb64eff9b5

func (Result) X分割 

func (r Result) X分割(数量 int) []Result

X分割 将一个 Result 分割成多个 Result， 每个数组的大小由 `size` 决定。 最后一块可能包含少于 size 个元素。 md5:e1e9bbb7e5ba1969

func (Result) X取Map数组 

func (r Result) X取Map数组() Map数组

X取Map数组 将 `r` 转换为一个 X取Map数组。 md5:ee79a42f10af264e

func (Result) X取json 

func (r Result) X取json() string

X取json 将 `r` 转换为JSON格式的内容。 md5:60a0626b0a333d14

func (Result) X取xml 

func (r Result) X取xml(根标记 ...string) string

X取xml 将 `r` 转换为 XML 格式的内容。 md5:31a335fedb874d26

func (Result) X取字段MapInt 

func (r Result) X取字段MapInt(字段名称 string) map[int]Map

X取字段MapInt 将 `r` 转换为一个 map[int]Map，其中的键由 `key` 指定。 md5:2c63f4f80e8a0e1b

func (Result) X取字段MapStr 

func (r Result) X取字段MapStr(字段名称 string) map[string]Map

X取字段MapStr 将 `r` 转换为一个键为指定字符串的 map[string]Map。 md5:43bb233c139ab262

func (Result) X取字段MapUint 

func (r Result) X取字段MapUint(字段名称 string) map[uint]Map

X取字段MapUint 将 `r` 转换为一个 map，其中的键是通过 `key` 指定的 uint 类型。 md5:0597073b149b7e00

func (Result) X取字段Map泛型类 

func (r Result) X取字段Map泛型类(字段名称 string) map[string]Value

X取字段Map泛型类 将 `r` 转换为一个 map[string]Value，其中的键由 `key` 指定。 注意，项目值可能为切片类型。 md5:0c805cb25cfa56ff

func (Result) X取字段数组 

func (r Result) X取字段数组(字段名称 ...string) []Value

X取字段数组 用于获取并返回指定列的值作为切片。 参数 `field` 是可选的，如果列字段只有一个。如果未给定 `field` 参数，其默认值为 `Result` 中第一条项的第一个字段名。 md5:f3e0a3bab6043d80

func (Result) X取指针列表 

func (r Result) X取指针列表(结构体数组指针 interface{}, 绑定到结构体属性名称 string, 结构体属性关联 ...string) (错误 error)

X取指针列表 将 `r` 转换为包含其他复杂结构体属性的结构体切片。 注意，参数 `structSlicePointer` 应该是 *[]struct/*[]*struct 类型。

使用示例 1：普通属性结构体关系： 

type EntityUser struct {
	Uid  int
	Name string
}

type EntityUserDetail struct {
	Uid     int
	Address string
}

type EntityUserScores struct {
	Id     int
	Uid    int
	Score  int
	Course string
}

type Entity struct {
	User       *EntityUser
	UserDetail *EntityUserDetail
	UserScores []*EntityUserScores
}

var users []*Entity
X取指针列表(&users, "User")
X取指针列表(&users, "User", "uid")
X取指针列表(&users, "UserDetail", "User", "uid:Uid")
X取指针列表(&users, "UserScores", "User", "uid:Uid")
X取指针列表(&users, "UserScores", "User", "uid")

使用示例 2：嵌入属性结构体关系： 

type EntityUser struct {
	Uid  int
	Name string
}

type EntityUserDetail struct {
	Uid     int
	Address string
}

type EntityUserScores struct {
	Id    int
	Uid   int
	Score int
}

type Entity struct {
	EntityUser
	UserDetail EntityUserDetail
	UserScores []EntityUserScores
}

var users []*Entity
X取指针列表(&users)
X取指针列表(&users, "UserDetail", "uid")
X取指针列表(&users, "UserScores", "uid")

示例代码中的 "User/UserDetail/UserScores" 参数指定了当前结果将绑定的目标属性结构体。

示例代码中的 "uid" 是结果表字段名，而 "Uid" 是相关结构体属性名，而不是绑定目标的属性名。 在示例代码中，它是 "Entity" 实体的 "User" 的属性名 "Uid"。它会根据给定的 `relation` 参数自动计算 HasOne/HasMany 关系。

可参考示例或单元测试用例以更清晰地理解此函数的工作方式。 md5:d6997acc67d472c4

func (Result) X取数组结构体指针 

func (r Result) X取数组结构体指针(结构体指针 interface{}) (错误 error)

X取数组结构体指针 将 `r` 转换为结构体切片。 注意参数 `pointer` 的类型应该是 `*[]struct` 或 `*[]*struct`。 md5:fef766b4997dca03

func (Result) X取数量 

func (r Result) X取数量() int

X取数量 返回结果列表的长度。 md5:9abccfc01a850f4f

func (Result) X是否为空 

func (r Result) X是否为空() bool

X是否为空 检查 `r` 是否为空，然后返回结果。 md5:4ee28a47e769cceb

type Schema 

type Schema struct {
	DB
}

Schema 是一个模式对象，从中可以创建一个模型。 md5:59296199d3fdabf5

type SoftTimeOption 

type SoftTimeOption struct {
	SoftTimeType SoftTimeType // 软时间字段的值类型。 md5:472088e64d8a928f
}

SoftTimeOption 是用于自定义 Model 的软时间功能的选项。 md5:fcc19f5ef8ad45e7

type SoftTimeType 

type SoftTimeType int

SoftTimeType自定义定义软时间字段类型。 md5:dac7cb3a21ca2d1d 

const (
	SoftTimeTypeAuto           SoftTimeType = 0 // (默认)根据表字段类型自动检测字段类型。 md5:92b9309fac6f4d09
	SoftTimeTypeTime           SoftTimeType = 1 // 使用日期时间作为字段值。 md5:fb9be1cf84e4192e
	SoftTimeTypeTimestamp      SoftTimeType = 2 // In unix seconds.
	SoftTimeTypeTimestampMilli SoftTimeType = 3 // In unix milliseconds.
	SoftTimeTypeTimestampMicro SoftTimeType = 4 // In unix microseconds.
	SoftTimeTypeTimestampNano  SoftTimeType = 5 // In unix nanoseconds.
)

type Sql 

type Sql struct {
	Sql           string        // SQL字符串（可能包含保留字符'?'）。 md5:8c5af3ca9410a41d
	Type          SqlType       // SQL operation type.
	Args          []interface{} // 这个SQL的参数。 md5:b4c3922763e4978a
	Format        string        // 包含在SQL中的参数格式化的SQL。 md5:555ebca4fe98838b
	Error         error         // Execution result.
	Start         int64         // 开始执行的时间戳（以毫秒为单位）。 md5:90bcb553c20da17f
	End           int64         // 结束执行的时间戳，以毫秒为单位。 md5:a69dc8d121bd65c6
	Group         string        // Group是执行SQL的配置组的名称。 md5:ae6f0deafeed211b
	Schema        string        // Schema是执行SQL时的配置模式名称。 md5:ac146287e6f60f27
	IsTransaction bool          // IsTransaction 标记此 SQL 语句是否在事务中执行。 md5:df029c1ffc72fbf7
	RowsAffected  int64         // RowsAffected 标记了当前 SQL 语句所影响或检索到的数量。 md5:24de0b6ae028d942
}

Sql 是用于记录 SQL 的结构体。 md5:00be6a573786ce1b

type SqlResult 

type SqlResult struct {
	X原生sql行记录 sql.Result
	X影响行数     int64
}

SqlResult是SQL操作的执行结果。它还支持行影响的批量操作结果。 md5:c89c5ab24627c936

func (*SqlResult) LastInsertId 

func (r *SqlResult) LastInsertId() (int64, error)

LastInsertId返回数据库对命令的响应生成的整数。通常，这将是在插入新行时来自“自动递增”列的。并非所有数据库都支持此功能，且此类语句的语法各不相同。 参见sql.Result。 md5:7236c1ac3f4fc094

func (*SqlResult) RowsAffected 

func (r *SqlResult) RowsAffected() (int64, error)

RowsAffected 返回更新、插入或删除操作影响的行数。并非所有数据库或数据库驱动程序都支持此功能。 参见 sql.Result。 md5:f41c8ccbf7344301

func (*SqlResult) X取影响行数PANI 

func (r *SqlResult) X取影响行数PANI() int64

X取影响行数PANI 返回受影响的行数，如果发生任何错误，则会引发恐慌。 md5:be151685a0da2b44

func (*SqlResult) X取最后插入IdPANI 

func (r *SqlResult) X取最后插入IdPANI() int64

X取最后插入IdPANI 返回最后的插入ID，如果发生任何错误，它将引发恐慌。 md5:bd23d169a4cb6738

type SqlType 

type SqlType string
const (
	SqlTypeBegin               SqlType = "DB.Begin"
	SqlTypeTXCommit            SqlType = "TX.Commit"
	SqlTypeTXRollback          SqlType = "TX.Rollback"
	SqlTypeExecContext         SqlType = "DB.ExecContext"
	SqlTypeQueryContext        SqlType = "DB.QueryContext"
	SqlTypePrepareContext      SqlType = "DB.PrepareContext"
	SqlTypeStmtExecContext     SqlType = "DB.Statement.ExecContext"
	SqlTypeStmtQueryContext    SqlType = "DB.Statement.QueryContext"
	SqlTypeStmtQueryRowContext SqlType = "DB.Statement.QueryRowContext"
)

type StatsItem 

type StatsItem interface {
	// Node 返回配置节点信息。 md5:868005c0df3fa483
	Node() ConfigNode

	// Stats 返回当前节点的连接状态统计信息。 md5:b497e68c5fce778b
	Stats() sql.DBStats
}

StatsItem 定义了配置节点的统计信息。 md5:95acda1876ad44fa

type Stmt 

type Stmt struct {
	*sql.Stmt
	// contains filtered or unexported fields
}

Stmt 是一个预处理语句。 Stmt 安全地支持多个 goroutine 并发使用。

如果在一个 Tx 或 Conn 上准备了一个 Stmt，它将永久绑定到单一的底层连接上。如果该 Tx 或 Conn 关闭了，Stmt 将变得无法使用，并且所有操作都将返回错误。 如果在一个 DB 上准备了一个 Stmt，它将在 DB 的整个生命周期内保持可用。当 Stmt 需要在新的底层连接上执行时，它会自动在新连接上为自己做准备。 md5:cf1394a31e88aa92

func (*Stmt) Close 

func (s *Stmt) Close() error

Close关闭语句。 md5:73ebf594ef1ccf7c

func (*Stmt) ExecContext 

func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (sql.Result, error)

ExecContext 使用给定的参数执行一个预编译的语句，并返回一个总结语句影响的结果。 md5:aa3184ee6004a352

func (*Stmt) QueryContext 

func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*sql.Rows, error)

QueryContext 使用给定的参数执行一个预处理查询语句，并将查询结果作为*Rows返回。 md5:2dc9d8dfa34a3cb1

func (*Stmt) QueryRow 

func (s *Stmt) QueryRow(args ...interface{}) *sql.Row

QueryRow 执行一个预处理的查询语句，使用给定的参数。如果在执行语句时发生错误，该错误将通过调用返回的 *Row 的 Scan 方法返回，*Row 总是非空的。如果查询没有选择任何行，*Row 的 Scan 将返回 ErrNoRows。否则，*Row 的 Scan 会扫描选中的第一行并忽略其余行。

示例用法： 

var name string
err := nameByUseridStmt.QueryRow(id).Scan(&name)

md5:3b2851663bab6cd6

func (*Stmt) QueryRowContext 

func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *sql.Row

QueryRowContext 使用给定的参数执行预处理查询语句。 如果在执行语句时发生错误，该错误将通过调用返回的*Row的Scan方法返回，该*Row始终非空。 如果查询没有选择任何行，*Row的Scan将返回ErrNoRows。 否则，*Row的Scan会扫描选中的第一行并丢弃其余部分。 md5:a2aed2939b0e481c

func (*Stmt) X执行 

func (s *Stmt) X执行(参数 ...interface{}) (sql.Result, error)

X执行 使用给定的参数执行预处理语句，并返回一个 Result 来概括该语句的影响。 md5:7ff0a9731fb27dd1

func (*Stmt) X查询 

func (s *Stmt) X查询(参数 ...interface{}) (*sql.Rows, error)

X查询 使用给定的参数执行预编译的查询语句，并将查询结果返回为一个 *Rows 对象。 md5:5028edd0d7332759

type TX 

type TX interface {
	Link

	X设置上下文并取副本(ctx context.Context) TX
	X原生SQL(rawSql string, args ...interface{}) *Model
	X创建Model对象(tableNameQueryOrStruct ...interface{}) *Model
	X关联对象(object interface{}) *Model

	X事务开启() error
	X事务提交() error
	X事务回滚() error
	X事务(ctx context.Context, f func(ctx context.Context, tx TX) error) (err error)

	X原生SQL查询(sql string, args ...interface{}) (result Result, err error)
	X原生SQL执行(sql string, args ...interface{}) (sql.Result, error)
	X原生sql取参数预处理对象(sql string) (*Stmt, error)

	GetAll别名(sql string, args ...interface{}) (Result, error)
	X原生SQL查询单条记录(sql string, args ...interface{}) (Record, error)
	X原生SQL查询单条到结构体指针(obj interface{}, sql string, args ...interface{}) error
	X原生SQL查询到结构体数组指针(objPointerSlice interface{}, sql string, args ...interface{}) error
	X原生SQL查询到结构体指针(pointer interface{}, sql string, args ...interface{}) error
	X原生SQL查询字段值(sql string, args ...interface{}) (Value, error)
	X原生SQL查询字段计数(sql string, args ...interface{}) (int64, error)

	X插入(table string, data interface{}, batch ...int) (sql.Result, error)
	X插入并跳过已存在(table string, data interface{}, batch ...int) (sql.Result, error)
	X插入并取ID(table string, data interface{}, batch ...int) (int64, error)
	X插入并替换已存在(table string, data interface{}, batch ...int) (sql.Result, error)
	X插入并更新已存在(table string, data interface{}, batch ...int) (sql.Result, error)
	X更新(table string, data interface{}, condition interface{}, args ...interface{}) (sql.Result, error)
	X删除(table string, condition interface{}, args ...interface{}) (sql.Result, error)

	X取上下文对象() context.Context
	X取DB对象() DB
	X底层取事务对象() *sql.Tx
	X是否已关闭() bool

	X保存事务点(point string) error
	X回滚事务点(point string) error
}

TX 定义 ORM 事务操作的接口。 md5:d71a7d0434928cac

func X事务从上下文取对象 

func X事务从上下文取对象(上下文 context.Context, group string) TX

X事务从上下文取对象 从上下文中获取并返回事务对象。 它通常用于嵌套事务功能，如果之前未设置，则返回nil。 md5:21e22b68139fc8b6

type TXCore 

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

TXCore是事务管理的结构体。 md5:c2173551528f4399

func (*TXCore) ExecContext 

func (tx *TXCore) ExecContext(ctx context.Context, sql string, args ...interface{}) (sql.Result, error)

ExecContext 实现了 Link.ExecContext 接口函数。 md5:9bd9a386cc5fc878

func (*TXCore) GetAll别名 

func (tx *TXCore) GetAll别名(sql string, 参数 ...interface{}) (Result, error)

GetAll别名 从数据库中查询并返回数据记录。 md5:dfdcfddaa70ab1d4

func (*TXCore) IsOnMaster 

func (tx *TXCore) IsOnMaster() bool

IsOnMaster 实现接口函数 Link.IsOnMaster。 md5:4fddd5d2ad612d30

func (*TXCore) IsTransaction 

func (tx *TXCore) IsTransaction() bool

IsTransaction 实现了 Link 接口中的函数 IsTransaction。 md5:692b7be612be52bd

func (*TXCore) PrepareContext 

func (tx *TXCore) PrepareContext(ctx context.Context, sql string) (*sql.Stmt, error)

PrepareContext 实现了接口 Link 的 PrepareContext 函数。 md5:b08e1c50bfb8f8e8

func (*TXCore) QueryContext 

func (tx *TXCore) QueryContext(ctx context.Context, sql string, args ...interface{}) (*sql.Rows, error)

QueryContext实现了Link.QueryContext接口函数。 md5:f42e7710688a27fc

func (*TXCore) X事务 

func (tx *TXCore) X事务(上下文 context.Context, 回调函数 func(上下文 context.Context, tx TX) error) (错误 error)

X事务 包装了使用函数 `f` 执行的事务逻辑。 如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。如果函数 `f` 返回 nil，它将提交事务并返回 nil。

注意，在函数 `f` 中不应手动提交或回滚事务，因为这些操作将由这个函数自动处理。 md5:8906440d4dbbef1f

func (*TXCore) X事务回滚 

func (tx *TXCore) X事务回滚() error

X事务回滚 会回滚当前事务。 注意，在嵌套事务过程中，它会回滚当前的事务；否则，它将回滚整个事务。 md5:0c483721f8447f53

func (*TXCore) X事务开启 

func (tx *TXCore) X事务开启() error

X事务开启 启动一个嵌套事务过程。 md5:1b04e48800ebefdd

func (*TXCore) X事务提交 

func (tx *TXCore) X事务提交() error

X事务提交 提交当前事务。 注意，如果处于嵌套事务过程中，它会释放之前的保存事务点， 否则，它将提交整个事务。 md5:9ca50fd58870ed9e

func (*TXCore) X保存事务点 

func (tx *TXCore) X保存事务点(事务点名称 string) error

X保存事务点 执行 `SAVEPOINT xxx` SQL 语句，该语句在当前点保存事务。 参数 `point` 指定将被保存到服务器的保存点名称。 md5:f4061450298afabd

func (*TXCore) X关联对象 

func (tx *TXCore) X关联对象(关联结构体 interface{}) *Model

X关联对象 的行为类似于 Core.X关联对象，但它是在事务上操作。 参见 Core.X关联对象。 md5:37000d6ea41561fc

func (*TXCore) X创建Model对象 

func (tx *TXCore) X创建Model对象(表名或结构体 ...interface{}) *Model

X创建Model对象 类似于 Core.X创建Model对象，但它是基于事务操作的。 请参阅 Core.X创建Model对象。 md5:2c5866afc2e5dd90

func (*TXCore) X删除 

func (tx *TXCore) X删除(表名称 string, 条件 interface{}, 参数 ...interface{}) (sql.Result, error)

X删除 执行 "DELETE FROM ... " 语句针对该表。

`condition` 参数可以是字符串、映射、gmap、切片、结构体或指向结构体的指针等多种类型。 它常与参数 `args` 一起使用。 例如： "uid=10000", "uid", 10000 "money>? AND name like ?", 99999, "vip_%" "status IN (?)", g.Slice{1,2,3} "age IN(?,?)", 18, 50 User{ Id : 1, UserName : "john"}. md5:c6c87830434eba7d

func (*TXCore) X原生SQL 

func (tx *TXCore) X原生SQL(原生Sql string, 参数 ...interface{}) *Model

func (*TXCore) X原生SQL执行 

func (tx *TXCore) X原生SQL执行(sql string, 参数 ...interface{}) (sql.Result, error)

X原生SQL执行 在事务上执行非查询操作。 参见Core.X原生SQL执行。 md5:043edf012223f310

func (*TXCore) X原生SQL查询 

func (tx *TXCore) X原生SQL查询(sql string, 参数 ...interface{}) (结果 Result, 错误 error)

X原生SQL查询 在事务上执行查询操作。 请参阅Core.X原生SQL查询。 md5:0d7503cceb0dc1d6

func (*TXCore) X原生SQL查询到结构体指针 

func (tx *TXCore) X原生SQL查询到结构体指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

X原生SQL查询到结构体指针 从数据库查询一个或多个记录，并将它们转换为给定的结构体或结构体数组。

如果参数 `pointer` 是结构体指针类型，它内部会调用 GetStruct 进行转换。如果参数 `pointer` 是切片类型，它内部会调用 GetStructs 进行转换。 md5:c1dbdab7a7c29c51

func (*TXCore) X原生SQL查询到结构体数组指针 

func (tx *TXCore) X原生SQL查询到结构体数组指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

X原生SQL查询到结构体数组指针 从数据库查询记录，并将它们转换为给定的结构体。参数 `pointer` 应该是结构体切片的类型：[]struct 或 []*struct。 md5:af7dfbf46c6660c6

func (*TXCore) X原生SQL查询单条到结构体指针 

func (tx *TXCore) X原生SQL查询单条到结构体指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

X原生SQL查询单条到结构体指针 从数据库中查询一条记录，并将其转换为给定的结构体。 参数 `pointer` 应该是指向结构体的指针。 md5:7ddc0d419d6cd2aa

func (*TXCore) X原生SQL查询单条记录 

func (tx *TXCore) X原生SQL查询单条记录(sql string, 参数 ...interface{}) (Record, error)

X原生SQL查询单条记录 从数据库中查询并返回一条记录。 md5:9552f7e095f58141

func (*TXCore) X原生SQL查询字段值 

func (tx *TXCore) X原生SQL查询字段值(sql string, 参数 ...interface{}) (Value, error)

X原生SQL查询字段值 从数据库查询并返回字段值。 SQL 应该只查询数据库中的一个字段，否则它将只返回结果中的一个字段。 md5:96794360fadbc288

func (*TXCore) X原生SQL查询字段计数 

func (tx *TXCore) X原生SQL查询字段计数(sql string, 参数 ...interface{}) (int64, error)

X原生SQL查询字段计数 从数据库中查询并返回计数。 md5:a8368d39f4a58979

func (*TXCore) X原生sql取参数预处理对象 

func (tx *TXCore) X原生sql取参数预处理对象(sql string) (*Stmt, error)

X原生sql取参数预处理对象 创建一个预处理语句，以便后续的查询或执行。 可以从返回的语句中并发地运行多个查询或执行。 调用者必须在不再需要该语句时调用语句的 Close 方法。 md5:16334dc7db1c37a9

func (*TXCore) X取DB对象 

func (tx *TXCore) X取DB对象() DB

X取DB对象 返回当前事务的DB。 md5:26a64f5fed9954b6

func (*TXCore) X取上下文对象 

func (tx *TXCore) X取上下文对象() context.Context

X取上下文对象 返回当前事务的上下文。 md5:e3cb35516cebab84

func (*TXCore) X回滚事务点 

func (tx *TXCore) X回滚事务点(事务点名称 string) error

X回滚事务点 执行 `ROLLBACK TO SAVEPOINT xxx` SQL语句，回滚到指定的保存点事务。 参数 `point` 指定了之前保存的保存点名称。 md5:e347c163ad8fefa7

func (*TXCore) X底层取事务对象 

func (tx *TXCore) X底层取事务对象() *sql.Tx

X底层取事务对象 返回当前事务的底层事务对象。 md5:31b14245dcb30833

func (*TXCore) X插入 

func (tx *TXCore) X插入(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入 执行 "INSERT INTO..." 语句来操作表。 如果表中已经存在数据的唯一记录，它会返回错误。

参数 `data` 可以是 map、gmap、struct、*struct、[]map 或 []struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

参数 `batch` 在给定数据为切片时，指定批量操作的次数。 md5:fd75d343f485b8dc

func (*TXCore) X插入并取ID 

func (tx *TXCore) X插入并取ID(表名称 string, 值 interface{}, 批量操作行数 ...int) (int64, error)

X插入并取ID 执行插入操作，并返回自动生成的最后一个插入id。 md5:8d00b40a35fa48a5

func (*TXCore) X插入并更新已存在 

func (tx *TXCore) X插入并更新已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并更新已存在 执行 "INSERT INTO ... ON DUPLICATE KEY UPDATE..." 语句来操作表。 如果保存的数据中存在主键或唯一索引，它将更新记录；否则，将在表中插入新记录。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

如果给定的数据是切片类型，它将进行批量保存。可选参数 `batch` 指定了批量操作的次数。 md5:c76721f5e0b01424

func (*TXCore) X插入并替换已存在 

func (tx *TXCore) X插入并替换已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并替换已存在 用于执行针对该表的 "REPLACE INTO..." 语句。如果表中已经存在数据的唯一记录，它会删除该记录并插入新的。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"}})

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。如果给定的数据是切片类型，它将进行批量替换，并可选地通过参数 `batch` 指定批量操作次数。 md5:69ecd0994eab5bbb

func (*TXCore) X插入并跳过已存在 

func (tx *TXCore) X插入并跳过已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

X插入并跳过已存在 执行 "INSERT IGNORE INTO ..." 语句针对该表。 如果表中已存在该数据的唯一记录，则忽略插入操作。

参数 `data` 可以是 map/gmap/struct/*struct/[]map/[]struct 等类型。 例如： Data(g.Map{"uid": 10000, "name": "john"}) Data(g.Slice{g.Map{"uid": 10000, "name": "john"}, g.Map{"uid": 20000, "name": "smith"})

当给定的数据为切片时，参数 `batch` 指定批处理操作的计数。 md5:49f76901041c9819

func (*TXCore) X是否已关闭 

func (tx *TXCore) X是否已关闭() bool

X是否已关闭检查并返回此事务是否已经提交或回滚。 md5:cecc2f01ef3e3556

func (*TXCore) X更新 

func (tx *TXCore) X更新(表名称 string, 值 interface{}, 条件 interface{}, 参数 ...interface{}) (sql.Result, error)

X更新 执行表的 "UPDATE ... " 语句。

参数 `data` 可以是字符串、映射、gmap、结构体或指向结构体的指针等类型。 例如："uid=10000", "uid", 10000, g.Map{"uid": 10000, "name":"john"}

参数 `condition` 也可以是字符串、映射、gmap、切片或结构体及指向结构体的指针等类型。 常与参数 `args` 配合使用。 例如： "uid=10000", "uid", 10000 "money>? AND name like ?", 99999, "vip_%" "status IN (?)", g.Slice{1,2,3} "age IN(?,?)", 18, 50 User{ Id : 1, UserName : "john"}. md5:8651eb1bd7e10da0

func (*TXCore) X设置上下文并取副本 

func (tx *TXCore) X设置上下文并取副本(上下文 context.Context) TX

X设置上下文并取副本为当前事务设置上下文。 md5:da0e9ba442dc74f9

type TableField 

type TableField struct {
	Index   int         // 用于排序，因为map是无序的。 md5:2c2b51c0f42d0aa5
	X名称     string      // Field name.
	X类型     string      // 字段类型。例如：'int(10) unsigned'，'varchar(64)'。 md5:c5cb4af28fd84cc4
	Null    bool        // 字段可以为null，也可以不为null。 md5:eecc03ab53cc06c9
	Key     string      // The index information(empty if it's not an index). Eg: PRI, MUL.
	Default interface{} // 字段的默认值。 md5:e9e6c4fce349ba5e
	X额外     string      //额外的信息。例如：auto_increment。 md5:706ba1f1653042e0
	Comment string      // Field comment.
}

TableField 是用于表示表字段的结构体。 md5:dad00a23ddbc4525

type Value 

type Value = *gvar.Var // Value 是字段值的类型。 md5:f2d488e083da124a

type WhereBuilder 

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

WhereBuilder 在一个分组中持有多个where条件。 md5:184a682305e36f1a

func (*WhereBuilder) X取副本 

func (b *WhereBuilder) X取副本() *WhereBuilder

X取副本 克隆并返回一个与当前 WhereBuilder 相同的副本。 md5:d6ddf2152377c7f0

func (*WhereBuilder) X条件 

func (b *WhereBuilder) X条件(条件 interface{}, 参数 ...interface{}) *WhereBuilder

X条件 方法为构建器设置条件语句。参数 `where` 可以是多种类型，包括 字符串、映射、gmap（可能是自定义的映射类型）、切片、结构体、指针到结构体等。需要注意的是， 如果该方法被调用了多次，多个条件将会使用 "AND" 连接起来组成 WHERE 子句。 例如： X条件("uid=10000") X条件("uid", 10000) X条件("money>? AND name like ?", 99999, "vip_%") X条件("uid", 1).X条件("name", "john") X条件("status IN (?)", g.Slice{1,2,3}) X条件("age IN(?,?)", 18, 50) X条件(User{ Id : 1, UserName : "john"}) // 使用结构体作为查询条件 md5:38a2f7ff889346c5

func (*WhereBuilder) X条件NULL值 

func (b *WhereBuilder) X条件NULL值(字段名 ...string) *WhereBuilder

X条件NULL值 构建 `columns[0] IS NULL AND columns[1] IS NULL ...` 语句。 md5:9341218ae0c32357

func (*WhereBuilder) X条件NULL值并带前缀 

func (b *WhereBuilder) X条件NULL值并带前缀(字段前缀 string, 字段名 ...string) *WhereBuilder

X条件NULL值并带前缀 构建 `prefix.columns[0] IS NULL AND prefix.columns[1] IS NULL ...` 语句。 md5:ac08bde96048fdce

func (*WhereBuilder) X条件不包含 

func (b *WhereBuilder) X条件不包含(字段名 string, 不包含值 interface{}) *WhereBuilder

X条件不包含构建`column NOT IN (in)`语句。 md5:658ffbae4d294fa4

func (*WhereBuilder) X条件不包含并带前缀 

func (b *WhereBuilder) X条件不包含并带前缀(字段前缀 string, 字段名 string, 不包含值 interface{}) *WhereBuilder

X条件不包含并带前缀 用于构建 `prefix.column NOT IN (in)` 的SQL语句。 md5:3b790678c07a51fd

func (*WhereBuilder) X条件不等于 

func (b *WhereBuilder) X条件不等于(字段名 string, 值 interface{}) *WhereBuilder

X条件不等于 构建 `column != value` 语句。 md5:d409867c3e8a9641

func (*WhereBuilder) X条件不等于并带前缀 

func (b *WhereBuilder) X条件不等于并带前缀(字段前缀 string, 字段名 string, 值 interface{}) *WhereBuilder

X条件不等于并带前缀构建`prefix.column != value`语句。 md5:c1366e00cd0da49e

func (*WhereBuilder) X条件包含 

func (b *WhereBuilder) X条件包含(字段名 string, 包含值 interface{}) *WhereBuilder

X条件包含 构建 `column IN (in)` 语句。 md5:08648a50bb84e2ee

func (*WhereBuilder) X条件包含并带前缀 

func (b *WhereBuilder) X条件包含并带前缀(字段前缀 string, 字段名 string, 包含值 interface{}) *WhereBuilder

X条件包含并带前缀 构建 `prefix.column IN (in)` 语句。 md5:fd691f634711ba7f

func (*WhereBuilder) X条件取范围 

func (b *WhereBuilder) X条件取范围(字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件取范围构建`column BETWEEN min AND max`语句。 md5:cdb9b4a2942f3b60

func (*WhereBuilder) X条件取范围以外 

func (b *WhereBuilder) X条件取范围以外(字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件取范围以外构建`column NOT BETWEEN min AND max`语句。 md5:ac5d20d314a9fa0c

func (*WhereBuilder) X条件取范围以外并带前缀 

func (b *WhereBuilder) X条件取范围以外并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件取范围以外并带前缀 构建 `prefix.column NOT BETWEEN min AND max` 语句。 md5:a16703b511af05c3

func (*WhereBuilder) X条件取范围并带前缀 

func (b *WhereBuilder) X条件取范围并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件取范围并带前缀 构建 `prefix.column BETWEEN min AND max` 语句。 md5:e6176c55b8a31575

func (*WhereBuilder) X条件大于 

func (b *WhereBuilder) X条件大于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件大于 构建 `column > value` 语句。 md5:41527fa039c8a299

func (*WhereBuilder) X条件大于并带前缀 

func (b *WhereBuilder) X条件大于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件大于并带前缀构建`prefix.column > value`语句。 md5:61d5cbbb9f5422fd

func (*WhereBuilder) X条件大于等于 

func (b *WhereBuilder) X条件大于等于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件大于等于构建`column >= value`语句。 md5:fff159ae64237621

func (*WhereBuilder) X条件大于等于并带前缀 

func (b *WhereBuilder) X条件大于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件大于等于并带前缀 生成 `prefix.column >= value` 的语句。 md5:1b581ea600e215e7

func (*WhereBuilder) X条件小于 

func (b *WhereBuilder) X条件小于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件小于构建`column < value`语句。 md5:438e43e951037408

func (*WhereBuilder) X条件小于并带前缀 

func (b *WhereBuilder) X条件小于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件小于并带前缀 构建 `prefix.column < value` 语句。 md5:de5cb5259ef84499

func (*WhereBuilder) X条件小于等于 

func (b *WhereBuilder) X条件小于等于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件小于等于 构建 `column <= value` 的语句。 md5:149d7bc478d211fd

func (*WhereBuilder) X条件小于等于并带前缀 

func (b *WhereBuilder) X条件小于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件小于等于并带前缀构建`prefix.column <= value`语句。 md5:1c5d93f173a39b03

func (*WhereBuilder) X条件带前缀 

func (b *WhereBuilder) X条件带前缀(字段前缀 string, 条件 interface{}, 参数 ...interface{}) *WhereBuilder

X条件带前缀 的功能类似于 Where，但它会在 where 语句中的每个字段前添加一个前缀。 例如： X条件带前缀("order", "status", "paid") => WHERE `order`.`status`='paid' X条件带前缀("order", struct{Status:"paid", "channel":"bank"}) => WHERE `order`.`status`='paid' AND `order`.`channel`='bank'

这段注释的中文翻译为：

X条件带前缀 的行为与 Where 相似，但它会在 where 子句里的每个字段前加上一个前缀。 例如： X条件带前缀("order", "status", "paid") => 生成 WHERE `order`.`status`='paid' X条件带前缀("order", struct{Status:"paid", "channel":"bank"}) => 生成 WHERE `order`.`status`='paid' AND `order`.`channel`='bank' md5:062302edb484784b

func (*WhereBuilder) X条件并识别主键 

func (b *WhereBuilder) X条件并识别主键(条件 interface{}, 参数 ...interface{}) *WhereBuilder

X条件并识别主键 的逻辑与 Model.Where 相同，但当参数 `where` 是单个条件，如 int、string、float 或 slice 时，它将该条件视为主键值。也就是说，如果主键是 "id" 并且给定的 `where` 参数为 "123"，X条件并识别主键 函数会将条件解析为 "id=123"，而 Model.Where 则会将条件视为字符串 "123"。 md5:2545fa57bcbd235c

func (*WhereBuilder) X条件或 

func (b *WhereBuilder) X条件或(条件 interface{}, 参数 ...interface{}) *WhereBuilder

X条件或 向 WHERE 语句中添加“OR”条件。 md5:753c32f428b02541

func (*WhereBuilder) X条件或NULL值 

func (b *WhereBuilder) X条件或NULL值(字段名 ...string) *WhereBuilder

X条件或NULL值 在 `OR` 条件下构建 `columns[0] IS NULL OR columns[1] IS NULL ...` 语句。 md5:08d38a60dc594441

func (*WhereBuilder) X条件或NULL值并带前缀 

func (b *WhereBuilder) X条件或NULL值并带前缀(字段前缀 string, 字段名 ...string) *WhereBuilder

X条件或NULL值并带前缀 在"OR"条件中构建`prefix.columns[0] IS NULL OR prefix.columns[1] IS NULL ...`语句。 md5:facf88eb72f3d299

func (*WhereBuilder) X条件或不包含 

func (b *WhereBuilder) X条件或不包含(字段名 string, 不包含值 interface{}) *WhereBuilder

X条件或不包含构建`column NOT IN (in)`语句。 md5:433fd8a0f224fc24

func (*WhereBuilder) X条件或不包含并带前缀 

func (b *WhereBuilder) X条件或不包含并带前缀(字段前缀 string, 字段名 string, 不包含值 interface{}) *WhereBuilder

X条件或不包含并带前缀 用于构建 `prefix.column NOT IN (in)` 的SQL语句。 md5:bd296110bb5635a1

func (*WhereBuilder) X条件或不等于 

func (b *WhereBuilder) X条件或不等于(字段名 string, 值 interface{}) *WhereBuilder

X条件或不等于在`OR`条件下构建`column != value`语句。 md5:adc6d63e61bf279f

func (*WhereBuilder) X条件或不等于并带前缀 

func (b *WhereBuilder) X条件或不等于并带前缀(字段前缀 string, 字段名 string, 值 interface{}) *WhereBuilder

X条件或不等于并带前缀 在 OR 条件中构建 `prefix.column != value` 语句。 md5:385a9f9fb58b8fc3

func (*WhereBuilder) X条件或包含 

func (b *WhereBuilder) X条件或包含(字段名 string, 包含值 interface{}) *WhereBuilder

X条件或包含 在`OR`条件下构建`column IN (in)`语句。 md5:4bb93b5ae9a5e887

func (*WhereBuilder) X条件或包含并带前缀 

func (b *WhereBuilder) X条件或包含并带前缀(字段前缀 string, 字段名 string, 包含值 interface{}) *WhereBuilder

X条件或包含并带前缀 用于构建 `prefix.column IN (in)` 形式的 SQL 语句，在 `OR` 条件下。 md5:18e0cf5cc971267d

func (*WhereBuilder) X条件或取范围 

func (b *WhereBuilder) X条件或取范围(字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件或取范围 用于构建 `column BETWEEN min AND max` 语句，并在 `OR` 条件下使用。 md5:90f98622a1fd5981

func (*WhereBuilder) X条件或取范围以外 

func (b *WhereBuilder) X条件或取范围以外(字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件或取范围以外 用于构建在 `OR` 条件下的 `column NOT BETWEEN min AND max` 语句。 md5:f20408e0126bbbab

func (*WhereBuilder) X条件或取范围以外并带前缀 

func (b *WhereBuilder) X条件或取范围以外并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件或取范围以外并带前缀在`OR`条件下构建`prefix.column NOT BETWEEN min AND max`语句。 md5:15259f135308893b

func (*WhereBuilder) X条件或取范围并带前缀 

func (b *WhereBuilder) X条件或取范围并带前缀(字段前缀 string, 字段名 string, 最小值, 最大值 interface{}) *WhereBuilder

X条件或取范围并带前缀在`OR`条件下构建`prefix.column BETWEEN min AND max`语句。 md5:d7adaf273fa5681b

func (*WhereBuilder) X条件或大于 

func (b *WhereBuilder) X条件或大于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件或大于在`OR`条件下构建`column > value`语句。 md5:2289d39bb82e521f

func (*WhereBuilder) X条件或大于并带前缀 

func (b *WhereBuilder) X条件或大于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件或大于并带前缀 在 `OR` 条件下构建 `prefix.column > value` 的语句。 md5:d34b5bdc0e6b2fa8

func (*WhereBuilder) X条件或大于等于 

func (b *WhereBuilder) X条件或大于等于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件或大于等于在`OR`条件下构建`column >= value`语句。 md5:e178dd8cfc5661e5

func (*WhereBuilder) X条件或大于等于并带前缀 

func (b *WhereBuilder) X条件或大于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件或大于等于并带前缀 在 OR 条件中构建 `prefix.column >= value` 语句。 md5:d652ca0304ac835e

func (*WhereBuilder) X条件或小于 

func (b *WhereBuilder) X条件或小于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件或小于 在 `OR` 条件下构建 `column < value` 的语句。 md5:5517b3812e2c8e8b

func (*WhereBuilder) X条件或小于并带前缀 

func (b *WhereBuilder) X条件或小于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件或小于并带前缀在"OR"条件下构建`prefix.column < value`语句。 md5:c1a6baf94f553043

func (*WhereBuilder) X条件或小于等于 

func (b *WhereBuilder) X条件或小于等于(字段名 string, 比较值 interface{}) *WhereBuilder

X条件或小于等于 在 OR 条件中构建 `column <= value` 语句。 md5:3b0287bd1f8030ce

func (*WhereBuilder) X条件或小于等于并带前缀 

func (b *WhereBuilder) X条件或小于等于并带前缀(字段前缀 string, 字段名 string, 比较值 interface{}) *WhereBuilder

X条件或小于等于并带前缀 在“OR”条件下构建 `prefix.column <= value` 语句。 md5:77072877b38f04a8

func (*WhereBuilder) X条件或并带前缀 

func (b *WhereBuilder) X条件或并带前缀(字段前缀 string, 条件 interface{}, 参数 ...interface{}) *WhereBuilder

X条件或并带前缀 的功能类似于 WhereOr，但它会在 WHERE 子句中的每个字段前添加一个前缀。 例如： X条件或并带前缀("order", "status", "paid") => WHERE xxx OR (`order`.`status`='paid') X条件或并带前缀("order", struct{Status:"paid", "channel":"bank"}) => WHERE xxx OR (`order`.`status`='paid' AND `order`.`channel`='bank')

这意味着 X条件或并带前缀 函数允许你在一个 WHERE 子句中指定多个条件，并且自动为这些条件的字段名加上一个指定的前缀，以便清晰地指向某个表或结构。它可以处理单个字段值的情况，也可以处理包含多个键值对的结构体，以生成更复杂的逻辑组合。 md5:2358d43541f472f5

func (*WhereBuilder) X条件或格式化 

func (b *WhereBuilder) X条件或格式化(格式 string, 参数 ...interface{}) *WhereBuilder

X条件或格式化 使用fmt.Sprintf和参数构建`OR`条件字符串。 md5:aa04236f081a2885 Eg: X条件或格式化(`amount<? and status=%s`, "paid", 100) => WHERE xxx OR `amount`<100 and status='paid' X条件或格式化(`amount<%d and status=%s`, 100, "paid") => WHERE xxx OR `amount`<100 and status='paid'

func (*WhereBuilder) X条件或模糊匹配 

func (b *WhereBuilder) X条件或模糊匹配(字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件或模糊匹配 在 `OR` 条件中构建 `column LIKE 'like'` 语句。 md5:7a2d37411752fb51

func (*WhereBuilder) X条件或模糊匹配以外 

func (b *WhereBuilder) X条件或模糊匹配以外(字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件或模糊匹配以外 在 OR 条件中构建 `column NOT LIKE like` 语句。 md5:751e840816119632

func (*WhereBuilder) X条件或模糊匹配以外并带前缀 

func (b *WhereBuilder) X条件或模糊匹配以外并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件或模糊匹配以外并带前缀 在 `OR` 条件下构建 `prefix.column NOT LIKE 'like'` 语句。 md5:2785cbc79e811104

func (*WhereBuilder) X条件或模糊匹配并带前缀 

func (b *WhereBuilder) X条件或模糊匹配并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件或模糊匹配并带前缀在`OR`条件下构建`prefix.column LIKE 'like'`语句。 md5:c975b47e3a5cc2c1

func (*WhereBuilder) X条件或非Null 

func (b *WhereBuilder) X条件或非Null(字段名 ...string) *WhereBuilder

X条件或非Null 构建 `columns[0] IS NOT NULL OR columns[1] IS NOT NULL ...` 的 `OR` 条件语句。 md5:e122f662846a4ba4

func (*WhereBuilder) X条件或非Null并带前缀 

func (b *WhereBuilder) X条件或非Null并带前缀(字段前缀 string, 字段名 ...string) *WhereBuilder

X条件或非Null并带前缀 在`OR`条件中构建`prefix.columns[0] IS NOT NULL OR prefix.columns[1] IS NOT NULL ...`语句。 md5:9ecd3bffabf47cb7

func (*WhereBuilder) X条件格式化 

func (b *WhereBuilder) X条件格式化(格式 string, 参数 ...interface{}) *WhereBuilder

X条件格式化 使用 fmt.Sprintf 和参数构建条件字符串。 注意，如果`args`的数目超过`format`中的占位符， 多余的`args`将作为Model的WHERE条件参数。 例如： X条件格式化(`amount<? and status=%s`, "paid", 100) => WHERE `amount`<100 and status='paid' X条件格式化(`amount<%d and status=%s`, 100, "paid") => WHERE `amount`<100 and status='paid' md5:e4748efd7332202a

func (*WhereBuilder) X条件模糊匹配 

func (b *WhereBuilder) X条件模糊匹配(字段名 string, 通配符条件值 string) *WhereBuilder

X条件模糊匹配 构建 `column LIKE like` 语句。 md5:5cf0790f9754307f

func (*WhereBuilder) X条件模糊匹配以外 

func (b *WhereBuilder) X条件模糊匹配以外(字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件模糊匹配以外 构建 `column NOT LIKE like` 的 SQL 语句。 md5:683105cb42e27e3b

func (*WhereBuilder) X条件模糊匹配以外并带前缀 

func (b *WhereBuilder) X条件模糊匹配以外并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件模糊匹配以外并带前缀构建`prefix.column NOT LIKE like`语句。 md5:083bd1d45c368a83

func (*WhereBuilder) X条件模糊匹配并带前缀 

func (b *WhereBuilder) X条件模糊匹配并带前缀(字段前缀 string, 字段名 string, 通配符条件值 interface{}) *WhereBuilder

X条件模糊匹配并带前缀构建`prefix.column LIKE like`语句。 md5:baf08eac5c7dc2aa

func (*WhereBuilder) X条件非Null 

func (b *WhereBuilder) X条件非Null(字段名 ...string) *WhereBuilder

X条件非Null 构建 `columns[0] IS NOT NULL AND columns[1] IS NOT NULL ...` 语句。 md5:2444d6e2f6bcbf2d

func (*WhereBuilder) X条件非Null并带前缀 

func (b *WhereBuilder) X条件非Null并带前缀(字段前缀 string, 字段名 ...string) *WhereBuilder

X条件非Null并带前缀 构建 `prefix.columns[0] IS NOT NULL AND prefix.columns[1] IS NOT NULL ...` 语句。 md5:d5a307a7c3004dda

func (*WhereBuilder) X生成条件字符串及参数 

func (b *WhereBuilder) X生成条件字符串及参数() (条件字符串 string, 参数 []interface{})

X生成条件字符串及参数构建当前的WhereBuilder，并返回条件字符串和参数。 md5:08aa1af8cbe06d71

type WhereHolder 

type WhereHolder struct {
	Type     string        // Type of this holder.
	Operator int           // 该持有者的运算符。 md5:52eab23e6ea6fbdb
	Where    interface{}   // Where 参数，通常可以是字符串、映射或结构体类型。 md5:dc1254ec6b4f31fa
	Args     []interface{} // where参数的arguments。 md5:3ae3eaf7373aa4ff
	Prefix   string        // 字段前缀，例如："user."，"order."。 md5:1fc1d00029c03395
}

WhereHolder是用于准备where条件的持有者。 md5:be3c4766444c1f3c

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.