db类

func (*Core) GetAll别名 ¶

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

GetAll 从数据库查询并返回数据记录。

func (Core) MarshalJSON ¶

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

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

注意，这个接口主要为了应对 Go 语言版本小于 v1.14 时存在的一个 json 无限循环bug而实现的。

func (*Core) X事务 ¶

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

Transaction 通过函数 `f` 包装事务逻辑。如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。若函数 `f` 返回空（nil）错误，它将提交事务并返回空。 注意：在函数 `f` 中不应手动调用 Commit 或 Rollback 方法处理事务，因为这些操作在此函数中已自动完成。

func (*Core) X事务开启 ¶

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

Begin 开始并返回事务对象。 如果不再使用该事务，你应该调用事务对象的 Commit 或 Rollback 函数。 Commit 或 Rollback 函数也会自动关闭事务。

func (*Core) X关联对象 ¶

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

With 根据给定对象的元数据创建并返回一个ORM模型。

原注释未提及with使用方法, 以下摘自Model对象示例,仅供参考. With 启用关联查询，通过给定的属性对象指定开启。 常考"模型关联-静态关联"文档:https://goframe.org/pages/viewpage.action?pageId=7297190 例如，如果给定如下的结构体定义：

type User struct {
	 gmeta.Meta `orm:"table:user"` // 定义表名为 user
	 Id         int           `json:"id"`    // 用户ID
	 Name       string        `json:"name"`   // 用户名
	 UserDetail *UserDetail   `orm:"with:uid=id"` // 关联 UserDetail 表，通过 uid 等于 id 进行关联
	 UserScores []*UserScores `orm:"with:uid=id"` // 关联 UserScores 表，通过 uid 等于 id 进行关联
}

我们可以通过以下方式在属性 `UserDetail` 和 `UserScores` 上启用模型关联操作： db.With(User{}.UserDetail).With(User{}.UserScores).Scan(xxx) 或者： db.With(UserDetail{}).With(UserScores{}).Scan(xxx) 或者： db.With(UserDetail{}, UserScores{}).Scan(xxx)

func (*Core) X关闭数据库 ¶

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

Close 关闭数据库并阻止新的查询开始。 Close 会等待在服务器上已经开始处理的所有查询完成。

很少会关闭一个 DB，因为 DB 处理程序旨在长期存在并被多个 goroutine 共享。

func (*Core) X切换数据库 ¶

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

Schema 创建并返回一个模式（schema）。

func (*Core) X创建Model对象 ¶

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

Model 根据给定的模式创建并返回一个新的 ORM 模型。 参数 `tableNameQueryOrStruct` 可以是多个表名，也可以包含别名，如下所示：

1. 表名示例： db.Model("user") // 单个表名 db.Model("user u") // 带别名的表名 db.Model("user, user_detail") // 多个表名 db.Model("user u, user_detail ud") // 多个带别名的表名
2. 包含别名的表名示例： db.Model("user", "u") // 表名和对应的别名
3. 使用子查询作为表名的示例： db.Model("? AS a, ? AS b", subQuery1, subQuery2) // 使用子查询表达式作为模型，并为子查询结果设置别名

func (*Core) X删除 ¶

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

Delete 执行针对该表的 "DELETE FROM ... " 语句。

参数 `condition` 可以是字符串、映射（map/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"} 中文注释： Delete 方法用于执行对该数据表执行 "DELETE FROM ... " SQL语句。

参数 `condition` 支持多种类型，如字符串、字典(map/gmap)、数组、结构体、结构体指针等。 通常会结合参数 `args` 使用，例如以下示例： "uid=10000"，（条件为 uid 等于 10000） "uid", 10000 "money>? AND name like ?", 99999, "vip_%" （条件为 money 大于 99999 并且 name 字段匹配 "vip_%"） "status IN (?)", g.Slice{1,2,3} （条件为 status 字段在数组 [1,2,3] 中） "age IN(?,?)", 18, 50 （条件为 age 字段在范围 18 到 50 内） User{ Id : 1, UserName : "john"} （根据结构体定义的字段作为条件）

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

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

ClearCacheAll 从缓存中移除所有已缓存的SQL查询结果

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

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

ClearTableFieldsAll 清除当前配置组中所有已缓存的表字段。

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

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

ClearTableFields 删除当前配置组中特定的缓存表字段。

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

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

ClearCache 清除特定表的缓存SQL结果。

func (*Core) X原生SQL ¶

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

也可以直接直接执行原始sql,示例： db.Raw("SELECT * FROM `user` WHERE `name` = ?", "john").Scan(&result) 上述代码表示，通过执行原始SQL语句（根据"name"为"john"的条件查询user表中所有列），并使用Scan方法将查询结果绑定到result变量中。

func (*Core) X原生SQL执行 ¶

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

Exec方法将一个SQL查询语句提交给底层驱动执行并返回执行结果。 该方法主要用于数据的插入和更新操作。

func (*Core) X原生SQL查询 ¶

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

Query 将一个查询SQL语句提交给底层驱动并返回执行结果。 这个方法最常用于数据查询。

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

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

GetScan 从数据库查询一个或多个记录，并将它们转换为给定的结构体或结构体数组。

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

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

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

GetOne 从数据库查询并返回一条记录。

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

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

GetValue 从数据库查询并返回字段值。 SQL语句应当只查询数据库中的一个字段，否则它将仅返回结果中的一个字段。

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

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

GetCount 从数据库查询并返回计数。

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

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

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

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

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

Prepare 函数用于为后续查询或执行创建预编译语句。 从返回的语句可以并发地运行多个查询或执行操作。 当该语句不再需要时，调用者必须调用该语句的 Close 方法。

参数 `execOnMaster` 指定是否在主节点上执行 SQL，如果配置了主从模式， 则此参数为 false 时将在从节点上执行 SQL。

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

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

RowsToResult 将底层数据记录类型 sql.Rows 转换为 Result 类型。

func (*Core) X取Core对象 ¶

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

GetCore 返回底层的 *Core 对象。

func (*Core) X取DB对象 ¶

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

GetDB 返回底层的 DB（数据库）

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

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

GetCtx 返回当前数据库的上下文。 如果之前未设置上下文，则返回 `context.Background()`。

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

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

Master在主从配置的情况下，创建并从主节点返回一个连接。如果未配置主从，则返回默认连接。

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

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

Slave在主从配置的情况下，创建并返回从节点的连接。如果未配置主从，则返回默认连接。

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

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

GetFieldType通过名称获取并返回特定字段的字段类型对象。

func (*Core) X取字段类型 ¶

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

GetFieldTypeStr 通过名称检索并返回特定字段的字段类型字符串。

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

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

GetConfig 返回当前正在使用的节点配置。

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

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

FilteredLink 获取并返回可用于日志记录或跟踪目的的已过滤`linkInfo`。

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

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

GetLink 创建并返回底层的数据库连接对象，同时进行事务检查。 参数 `master` 指定在主从配置的情况下是否使用主节点。

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

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

GetLogger 返回 orm 的（日志器）

func (*Core) X取空跑特性 ¶

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

GetDryRun 返回 DryRun 的值。

func (*Core) X取缓存对象 ¶

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

GetCache 返回内部缓存对象。

func (*Core) X取表前缀 ¶

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

GetPrefix 返回已配置的表前缀字符串。

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

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

Tables 获取并返回当前模式的表。 它主要用于cli工具链中，用于自动生成模型。

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

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

GetTablesWithCache 使用缓存获取并返回当前数据库的表名。

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

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

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

参数 `link` 是可选的，如果给出 nil，则会自动获取一个原始的 SQL 连接作为其链接以执行必要的 SQL 查询。

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

为了提高性能，该函数使用了缓存特性，缓存有效期直到进程重启才会过期。

func (*Core) X取调试模式 ¶

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

GetDebug 返回调试值。

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

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

GetCtxTimeout 根据指定的超时类型返回上下文和取消函数。

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

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

GetGroup 返回已配置的组字符串。

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

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

GetSchema 返回已配置的架构。

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

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

PingMaster 用于向主节点发送心跳以检查身份验证或保持连接存活。

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

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

PingSlave 向从节点发送ping请求，用于检查身份验证或保持连接活跃。

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

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

Union 执行 "(SELECT xxx FROM xxx) UNION (SELECT xxx FROM xxx) ..." 语句。

func (*Core) X多表查询 ¶

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

UnionAll 执行 "(SELECT xxx FROM xxx) UNION ALL (SELECT xxx FROM xxx) ..." 语句。

func (*Core) X底层CheckLocalTypeForField ¶

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

CheckLocalTypeForField 检查并返回给定数据库类型对应的本地类型。

func (*Core) X底层ConvertDataForRecord ¶

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

ConvertDataForRecord 是一个非常重要的函数，用于将任何要作为记录插入到表/集合中的数据进行转换。

参数 `value` 应为 *map、map、*struct 或 struct 类型。对于 struct，它支持嵌套的 struct 定义。

func (*Core) X底层ConvertValueForField ¶

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

ConvertValueForField 将值转换为目标记录字段的类型。 参数`fieldType`是目标记录字段。 参数`fieldValue`是要提交到记录字段的值。

func (*Core) X底层ConvertValueForLocal ¶

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

ConvertValueForLocal 将值根据数据库字段类型名称转换为本地 Golang 类型的值。 参数 `fieldType` 为小写形式，例如： `float(5,2)`、`unsigned double(5,2)`、`decimal(10,2)`、`char(45)`、`varchar(100)` 等。

func (*Core) X底层DoCommit ¶

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

DoCommit 将当前SQL语句及其参数提交给底层SQL驱动执行。

func (*Core) X底层DoFilter ¶

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

DoFilter 是一个钩子函数，在 SQL 语句及其参数提交给底层驱动程序之前对其进行过滤。 参数 `link` 指定了当前数据库连接操作对象。您可以在 SQL 字符串 `sql` 和其参数 `args` 提交给驱动程序之前，根据需要自由修改它们。

func (*Core) X底层MasterLink ¶

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

MasterLink 表现得像函数 Master，但额外添加了一个 `schema` 参数用于指定连接的模式。它被定义为内部使用。 有关更多信息，请参阅 Master。

func (*Core) X底层QuoteString ¶

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

QuoteString 用引号字符对字符串进行引用。例如以下字符串： "user", "user u", "user,user_detail", "user u, user_detail ut", "u.id asc".

可以将 `string` 的含义视为包含列部分的语句字符串中的一部分。

func (*Core) X底层QuoteWord ¶

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

2024-01-09 改成内部方法,此方法属于底层, 几乎用不到. QuoteWord 检查给定字符串 `s` 是否为一个单词， 如果是，它会使用数据库的安全字符对 `s` 进行引用，并返回引述后的字符串； 否则，它将直接返回未经修改的 `s`。

这里的“单词”可以理解为列名。

func (*Core) X底层SlaveLink ¶

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

SlaveLink 表现得像函数 Slave，但额外添加了一个 `schema` 参数用于指定连接的模式。它被定义为内部使用。 有关更多信息，请参阅 Slave。

func (*Core) X底层删除 ¶

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

DoDelete 执行针对表的 "DELETE FROM ..." 语句。 该函数通常用于自定义接口定义，无需手动调用。

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

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

DoExec通过给定的link对象，将SQL字符串及其参数提交给底层驱动，并返回执行结果。

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

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

DoQuery 通过给定的link对象，将sql字符串及其参数提交到底层驱动，并返回执行结果。

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

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

DoPrepare在给定的link对象上调用prepare函数，并返回statement对象。

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

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

GetChars 返回当前数据库的安全字符。 默认情况下，此方法不做任何操作。

func (*Core) X底层插入 ¶

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

DoInsert 插入或更新给定表中的数据。 该函数通常用于自定义接口定义，您无需手动调用它。 参数 `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：如果数据中存在唯一/主键，则忽略插入操作。

func (*Core) X底层更新 ¶

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

DoUpdate 执行针对该表的 "UPDATE ... " 语句。 该函数通常用于自定义接口定义，您无需手动调用它。

func (*Core) X底层查询 ¶

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

DoSelect 从数据库查询并返回数据记录。

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

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

QuotePrefixTableName 为表名添加前缀字符串和引用字符。 它处理诸如以下格式的表名： "user", "user u", "user,user_detail", "user u, user_detail ut", "user as u, user_detail as ut"。

注意，此函数会自动检查表名是否已添加了前缀， 如果已经添加，则不对表名做任何处理；否则，将前缀添加到表名中。

func (*Core) X插入 ¶

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

Insert 执行针对该表的 "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` 指定了批量操作的数量。

func (*Core) X插入并取ID ¶

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

InsertAndGetId 执行插入操作，并返回自动生成的最后一个插入ID。

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

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

Save 执行针对表的 "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` 指定了批量操作的数量。

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

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

Replace 执行针对该表的 "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` 指定了批量操作的数量。

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

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

InsertIgnore 执行针对表的 "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` 指定批量操作的数量。

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

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

HasField 判断字段是否在表中存在。

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

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

HasTable 判断给定的表名是否存在于数据库中。

func (*Core) X更新 ¶

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

Update 执行针对该表的 "UPDATE ... " 语句。

参数 `data` 可以为 string/map/gmap/struct/*struct 等类型。 例如："uid=10000"、"uid", 10000、g.Map{"uid": 10000, "name":"john"}

参数 `condition` 可以为 string/map/gmap/slice/struct/*struct 等类型，通常与参数 `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"} 注：这里的 `g.Map` 和 `g.Slice` 是一种特定的 Go 语言数据结构（可能是自定义类型），分别代表映射和切片。

func (*Core) X格式化Sql ¶

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

FormatSqlBeforeExecuting 在执行SQL之前，对SQL字符串及其参数进行格式化处理。 在SQL过程中，内部函数handleArguments可能被调用两次， 但请不用担心，这是安全且高效的。

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

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

Ctx 是一个链式函数，它创建并返回一个新的 DB 对象，该对象是对当前 DB 对象的浅复制，并且其中包含给定的上下文。 注意，返回的这个 DB 对象只能使用一次，所以不要将其赋值给全局或包级别的变量以长期使用。

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

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

SetLogger 设置orm的记录器。

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

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

SetMaxOpenConnCount 设置与数据库的最大连接数。

如果 MaxIdleConns 大于0且新的 MaxOpenConns 值小于 MaxIdleConns，则 MaxIdleConns 会相应减少以匹配新的 MaxOpenConns 限制。

若 n <= 0，则表示对打开的连接数没有限制。 默认值为 0（无限制）。

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

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

SetMaxConnLifeTime 设置单个连接可重用的最大时长。

到期的连接在重用前可能被延迟关闭。

如果 d <= 0，则不会因为连接存在时间过长而关闭连接。

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

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

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

如果MaxOpenConns大于0但小于新的MaxIdleConns，则新的MaxIdleConns将减小以匹配MaxOpenConns限制。

若n <= 0，则不保留任何空闲连接。

当前默认的最大空闲连接数为2，这在未来版本中可能会发生变化。 以下是逐行翻译： ```go SetMaxIdleConnCount 用于设置闲置连接池中允许的最大连接数量。

如果 MaxOpenConns 大于0但小于新设置的 MaxIdleConns 值， 那么新的 MaxIdleConns 将会被调整以匹配 MaxOpenConns 的限制。

如果传入的参数 n 小于等于0，则不会保留任何空闲连接。

目前默认的最大空闲连接数是2，在未来版本中这个数值可能会有所更改。

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

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

SetDryRun 用于启用/禁用 DryRun 功能。

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

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

SetDebug用于开启或关闭调试模式。

func (*DriverDefault) New ¶

func (d *DriverDefault) New(core *Core, node *X配置项) (DB, error)

New 创建并返回一个用于 mysql 的数据库对象。 它实现了 gdb.Driver 接口，以便进行额外的数据库驱动安装。

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

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

PingMaster 用于向主节点发送心跳以检查身份验证或保持连接存活。

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

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

PingSlave 向从节点发送ping请求，用于检查身份验证或保持连接活跃。

func (*DriverDefault) X底层Open ¶

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

Open 创建并返回一个用于 mysql 的底层 sql.DB 对象。 注意，它默认会将 time.Time 类型参数转换为本地时区。

func (*DriverWrapper) New ¶

func (d *DriverWrapper) New(core *Core, node *X配置项) (DB, error)

New 创建并返回一个用于 mysql 的数据库对象。 它实现了 gdb.Driver 接口，以便进行额外的数据库驱动安装。

func (*DriverWrapperDB) Open ¶

func (d *DriverWrapperDB) Open(node *X配置项) (db *sql.DB, err error)

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

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

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

Tables 获取并返回当前模式的表。 它主要用于cli工具链中，用于自动生成模型。

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

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

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

参数 `link` 是可选的，如果给出 nil，则会自动获取一个原始的 SQL 连接作为其链接以执行必要的 SQL 查询。

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

为了提高性能，该函数使用了缓存特性，缓存有效期直到进程重启才会过期。

func (*DriverWrapperDB) X底层插入 ¶

func (d *DriverWrapperDB) X底层插入(上下文 context.Context, 链接 Link, 表名称 string, list Map数组, 选项 DoInsertOption) (结果 sql.Result, 错误 error)

DoInsert 对给定表插入或更新数据。 该函数通常用于自定义接口定义，您无需手动调用它。 参数`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：如果数据中存在唯一/主键，则忽略插入操作。

func (*HookDeleteInput) Next ¶

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

Next调用下一个钩子处理器。

func (*HookInsertInput) Next ¶

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

Next调用下一个钩子处理器。

func (*HookSelectInput) Next ¶

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

Next调用下一个钩子处理器。

func (*HookUpdateInput) Next ¶

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

Next调用下一个钩子处理器。

func (*Model) Hook ¶

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

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

func (*Model) Offset ¶

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

Offset 设置模型的 "OFFSET" 语句。 它只对某些数据库有意义，如 SQLServer、PostgreSQL 等。

func (*Model) X事务 ¶

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

Transaction 通过函数 `f` 包装事务逻辑。如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。若函数 `f` 返回空（nil）错误，它将提交事务并返回空。 注意：在函数 `f` 中不应手动调用 Commit 或 Rollback 方法处理事务，因为这些操作在此函数中已自动完成。

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

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

WithAll 开启在所有具有"struct"标签中包含"with"标签的对象上的模型关联操作。 常考"模型关联-静态关联"文档:https://goframe.org/pages/viewpage.action?pageId=7297190

func (*Model) X关联对象 ¶

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

With 启用关联查询，通过给定的属性对象指定开启。 常考"模型关联-静态关联"文档:https://goframe.org/pages/viewpage.action?pageId=7297190 例如，如果给定如下的结构体定义：

type User struct {
	 gmeta.Meta `orm:"table:user"` // 定义表名为 user
	 Id         int           `json:"id"`    // 用户ID
	 Name       string        `json:"name"`   // 用户名
	 UserDetail *UserDetail   `orm:"with:uid=id"` // 关联 UserDetail 表，通过 uid 等于 id 进行关联
	 UserScores []*UserScores `orm:"with:uid=id"` // 关联 UserScores 表，通过 uid 等于 id 进行关联
}

我们可以通过以下方式在属性 `UserDetail` 和 `UserScores` 上启用模型关联操作： db.With(User{}.UserDetail).With(User{}.UserScores).Scan(xxx) 或者： db.With(UserDetail{}).With(UserScores{}).Scan(xxx) 或者： db.With(UserDetail{}, UserScores{}).Scan(xxx)

func (*Model) X内连接 ¶

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

InnerJoin does "INNER JOIN ... ON ..." statement on the model. The parameter `table` can be joined table and its joined condition, and also with its alias name。

Eg: Model("user").InnerJoin("user_detail", "user_detail.uid=user.uid") Model("user", "u").InnerJoin("user_detail", "ud", "ud.uid=u.uid") Model("user", "u").InnerJoin("SELECT xxx FROM xxx","a", "a.uid=u.uid").

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

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

InnerJoinOnFields 执行内连接操作。它用于指定不同的字段及比较运算符。

示例： Model("user").InnerJoinOnFields("order", "id", "=", "user_id") // 根据 id 等于 user_id 进行内连接 Model("user").InnerJoinOnFields("order", "id", ">", "user_id") // 根据 id 大于 user_id 进行内连接 Model("user").InnerJoinOnFields("order", "id", "<", "user_id") // 根据 id 小于 user_id 进行内连接 该函数主要用于在Go语言中进行数据库查询时，通过自定义字段与运算符实现两个表之间的内连接操作。

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

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

InnerJoinOnField 执行内连接操作，但它通过`相同的字段名`将两个表连接起来。

例如： Model("order").InnerJoinOnField("user", "user_id") // 使用user表与order表中user_id字段进行内连接 Model("order").InnerJoinOnField("product", "product_id") // 使用product表与order表中product_id字段进行内连接

func (*Model) X分割 ¶

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

Chunk 对查询结果进行迭代，指定 `size`（大小）和 `handler` 函数。 根据给定的 `size`，将查询结果分割成多个块，并对每个数据块应用 `handler` 函数进行处理。

func (*Model) X切换数据库 ¶

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

设置当前操作的模式。

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

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

Builder 创建并返回一个 WhereBuilder。请注意，该构建器支持链式调用，即链式安全。

func (*Model) X删除 ¶

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

Delete 执行 "DELETE FROM ..." 语句用于该模型。 可选参数 `where` 与 Model.Where 函数的参数相同， 请参阅 Model.Where。

func (*Model) X原生SQL ¶

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

Raw 将当前模型设置为原始SQL模型。 通常用于嵌入原始sql语句,如: g.Model("user").WhereLT("created_at", gdb.Raw("now()")).All() // SELECT * FROM `user` WHERE `created_at`<now() 参考文档:https://goframe.org/pages/viewpage.action?pageId=111911590&showComments=true

也可以直接直接执行原始sql,示例: db.Raw("SELECT * FROM `user` WHERE `name` = ?", "john").Scan(&result) 请参阅Core.Raw。

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

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

GetCtx 返回当前 Model 的上下文。 若此前未设置过上下文，则返回 `context.Background()`。

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

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

Master 标识以下操作将在主节点上执行。

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

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

Slave 标记在从属节点上执行的后续操作。 注意，只有在配置了从属节点时才有意义。

func (*Model) X取副本 ¶

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

Clone 创建并返回一个新的模型，该模型是当前模型的克隆版本。 注意，它使用深度复制进行克隆。

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

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

GetFieldsStr 函数从表中检索并返回所有字段，各字段之间用字符 ',' 连接。 可选参数 `prefix` 用于指定每个字段的前缀，例如：GetFieldsStr("u.").

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

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

GetFieldsExStr 从表中检索并返回不在参数 `fields` 中的字段，并使用字符 ',' 连接这些字段。 参数 `fields` 指定需要排除的字段。 可选参数 `prefix` 用于指定每个字段的前缀，例如：FieldsExStr("id", "u.")。

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

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

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

另请参阅 DriverMysql.TableFields。

func (*Model) X右连接 ¶

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

RightJoin 对模型执行 "RIGHT JOIN ... ON ..." 语句。 参数 `table` 可以是待连接的表及其连接条件，并且可以包含别名名称。

示例： Model("user").RightJoin("user_detail", "user_detail.uid=user.uid") // 连接 user 表和 user_detail 表，连接条件为 user_detail.uid 等于 user.uid Model("user", "u").RightJoin("user_detail", "ud", "ud.uid=u.uid") // 使用别名 u 和 ud 连接 user 表和 user_detail 表，连接条件为 ud.uid 等于 u.uid Model("user", "u").RightJoin("SELECT xxx FROM xxx","a", "a.uid=u.uid") // 将查询结果作为连接表，使用别名 u 和 a 连接 user 表和查询结果表，连接条件为 a.uid 等于 u.uid

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

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

RightJoinOnFields 执行右连接操作。它用于指定不同的字段以及比较运算符。

示例： Model("user").RightJoinOnFields("order", "id", "=", "user_id") // 用户表通过id字段等于order表中的user_id字段进行右连接 Model("user").RightJoinOnFields("order", "id", ">", "user_id") // 用户表通过id字段大于order表中的user_id字段进行右连接 Model("user").RightJoinOnFields("order", "id", "<", "user_id") // 用户表通过id字段小于order表中的user_id字段进行右连接 这段Go语言代码的注释翻译为中文注释，其功能是定义一个RightJoinOnFields方法，该方法用于执行SQL查询中的右连接操作，并允许用户自定义连接的字段及比较条件。

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

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

RightJoinOnField 执行 RightJoin 操作，但是它通过“相同字段名”将两个表连接起来。

例如： Model("order").InnerJoinOnField("user", "user_id") // 根据 user_id 字段将 order 表与 user 表进行内连接 Model("order").InnerJoinOnField("product", "product_id") // 根据 product_id 字段将 order 表与 product 表进行内连接 （注意：代码中的 InnerJoinOnField 应该是 RightJoinOnField，因为注释中提到的是 RightJoin。若确实为 RightJoin，请将上述翻译中的“内连接”替换为“右连接”。） 修正后的翻译： RightJoinOnField 执行 RightJoin 操作，但它是基于“相同字段名”将两个表进行连接。

例如： Model("order").RightJoinOnField("user", "user_id") // 根据 user_id 字段将 order 表与 user 表进行右连接 Model("order").RightJoinOnField("product", "product_id") // 根据 product_id 字段将 order 表与 product 表进行右连接

func (*Model) X处理函数 ¶

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

Handler calls each of `handlers` on current Model and returns a new Model. ModelHandler 是一个函数，用于处理给定的 Model，并返回一个经过自定义修改的新 Model。

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

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

Union 为给定的模型执行 "(SELECT xxx FROM xxx) UNION (SELECT xxx FROM xxx) ..." 类似的SQL语句查询。

func (*Model) X多表查询 ¶

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

UnionAll 对模型执行“(SELECT xxx FROM xxx) UNION ALL (SELECT xxx FROM xxx) ...”语句。

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

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

Fields 用于指定需要操作的表字段，包括查询字段、写入字段、更新字段等过滤； 参数 `fieldNamesOrMapStruct` 可以是 string/map/*map/struct/*struct 类型。 多个字段之间使用字符 ',' 连接。

查询过滤示例: g.Model("user").Fields("uid, nickname").Order("uid asc").All() //SELECT `uid`,`nickname` FROM `user` ORDER BY `uid` asc

写入过滤示例: m := g.Map{ "uid" : 10000, "nickname" : "John Guo", "passport" : "john", "password" : "123456", } g.Model(table).Fields("nickname,passport,password").Data(m).Insert() //INSERT INTO `user`(`nickname`,`passport`,`password`) VALUES('John Guo','john','123456')

示例： Fields("id", "name", "age") // 通过字符串直接指定字段名 Fields([]string{"id", "name", "age"}) // 通过字符串切片指定字段名 Fields(map[string]interface{}{"id":1, "name":"john", "age":18}) // 通过键值对映射指定字段和值 Fields(User{ Id: 1, Name: "john", Age: 18}) // 通过结构体实例指定字段和值

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

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

FieldsPrefix 函数的功能与 Fields 相同，但会在每个字段前额外添加一个前缀。

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

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

FieldsEx 将`fieldNamesOrMapStruct` 追加到模型的排除操作字段列表中， 多个字段之间使用逗号字符 ',' 连接。 注意，此函数仅支持单表操作。 参数 `fieldNamesOrMapStruct` 可以是 string、map、*map 或 struct、*struct 类型。 请同时参考 Fields 函数。

查询排除过滤例子 g.Model("user").FieldsEx("passport, password").All() //SELECT `uid`,`nickname` FROM `user`

写入排除过滤例子 m := g.Map{ "uid" : 10000, "nickname" : "John Guo", "passport" : "john", "password" : "123456", } g.Model(table).FieldsEx("uid").Data(m).Insert() // INSERT INTO `user`(`nickname`,`passport`,`password`) VALUES('John Guo','john','123456')

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

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

FieldsExPrefix 函数的功能与 FieldsEx 相同，但会在每个字段前额外添加一个前缀。

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

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

FieldAvg 格式化并追加常用字段 `AVG(column)` 到模型的 select 字段中。 简单点说就是追加一个平均值的别名字段

追加平均值字段例子: db.Model(table).Fields("column").FieldAvg("column", "total") // AVG(`column`) AS `total`

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

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

FieldMax 格式化并追加常用字段 `MAX(column)` 到模型的 select 字段中。 简单点说就是追加一个最大值的别名字段

追加最大值字段例子: db.Model(table).Fields("column").FieldMax("column", "total") // MAX(`column`) AS `total`

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

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

FieldMin 格式化并追加常用字段 `MIN(column)` 到模型的 select 字段中。 简单点说就是追加一个最小值的别名字段

追加最小值字段例子: db.Model(table).Fields("column").FieldMin("column", "total") // MIN(`column`) AS `total`

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

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

FieldSum 格式化并追加常用字段 `SUM(column)` 到模型的 select 字段中。 简单点说就是追加一个求和的别名字段

追加求和字段例子: db.Model(table).Fields("column").FieldSum("column", "total") // SUM(`column`) AS `total`

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

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

FieldCount 格式化并追加计数字段别名到模型的 select 字段中。 简单点说就是追加一个计数的别名字段

追加计数字段例子: db.Model(table).Fields("id").FieldCount("id", "total") // COUNT(`id`) AS `total`

func (*Model) X左连接 ¶

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

LeftJoin 对模型执行 "LEFT JOIN ... ON ..." 语句。 参数 `table` 可以是联接表及其联接条件，并且可以带有别名名称。

示例： Model("user").LeftJoin("user_detail", "user_detail.uid=user.uid") // 用户表与用户详情表进行左连接，关联条件为 user_detail.uid 等于 user.uid Model("user", "u").LeftJoin("user_detail", "ud", "ud.uid=u.uid") // 使用别名，用户表（别名u）与用户详情表（别名ud）进行左连接，关联条件为 ud.uid 等于 u.uid Model("user", "u").LeftJoin("SELECT xxx FROM xxx","a", "a.uid=u.uid") // 将子查询结果作为联接表，并使用别名，用户表（别名u）与子查询结果（别名a）进行左连接，关联条件为 a.uid 等于 u.uid

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

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

LeftJoinOnFields 执行左连接操作。它用于指定不同的字段以及比较运算符。

例如： Model("user").LeftJoinOnFields("order", "id", "=", "user_id") // 根据 id 等于 user_id 进行左连接 Model("user").LeftJoinOnFields("order", "id", ">", "user_id") // 根据 id 大于 user_id 进行左连接 Model("user").LeftJoinOnFields("order", "id", "<", "user_id") // 根据 id 小于 user_id 进行左连接 这段 Go 代码的注释翻译成中文注释如上，该函数主要是对两个数据表进行左连接操作，并允许用户自定义连接条件中的字段和比较运算符。

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

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

LeftJoinOnField 执行类似 LeftJoin 的操作，但是它通过“相同字段名”将两个表连接起来。

例如： Model("order").LeftJoinOnField("user", "user_id") // 使用 user 表与 order 表的 user_id 字段进行左连接 Model("order").LeftJoinOnField("product", "product_id") // 使用 product 表与 order 表的 product_id 字段进行左连接

func (*Model) X排序 ¶

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

Order 为模型设置 "ORDER BY" 语句。

示例： Order("id desc") // 按 id 倒序排序 Order("id", "desc") // 等同于 Order("id desc") Order("id desc,name asc") // 先按 id 倒序，再按 name 正序排序 Order("id desc").Order("name asc") // 分别对 id 和 name 进行倒序和正序排序 Order(gdb.Raw("field(id, 3,1,2)")) // 使用原生表达式进行排序，如MySQL中的 field 函数指定排序字段的顺序

func (*Model) X排序ASC ¶

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

OrderAsc 为模型设置 "ORDER BY xxx ASC" 语句。

func (*Model) X排序Desc ¶

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

OrderDesc 为模型设置 "ORDER BY xxx DESC" 语句。

func (*Model) X排序分组 ¶

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

Group 设置模型的 "GROUP BY" 语句。

func (*Model) X排序随机 ¶

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

OrderRandom 为模型设置 "ORDER BY RANDOM()" 语句。

func (*Model) X插入 ¶

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

Insert 执行针对模型的 "INSERT INTO ..." 语句。 可选参数 `data` 与 Model.Data 函数的参数相同， 请参考 Model.Data。

func (*Model) X插入并取ID ¶

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

InsertAndGetId 执行插入操作，并返回自动生成的最后一个插入ID。

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

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

Save 执行 "INSERT INTO ... ON DUPLICATE KEY UPDATE..." 语句，针对给定的 model。 可选参数 `data` 与 Model.Data 函数的参数相同， 请参阅 Model.Data。

如果保存的数据中存在主键或唯一索引，则更新记录， 否则会在表中插入一条新记录。

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

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

Replace 执行针对模型的 "REPLACE INTO ..." 语句。 可选参数 `data` 与 Model.Data 函数的参数相同， 详情请参阅 Model.Data。

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

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

InsertIgnore 执行针对模型的 "INSERT IGNORE INTO ..." 语句。 可选参数 `data` 与 Model.Data 函数的参数相同， 请参阅 Model.Data。

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

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

HasField 判断字段是否在表中存在。

func (*Model) X更新 ¶

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

Update 执行针对模型的 "UPDATE ... " 语句。

如果提供可选参数 `dataAndWhere`，则 dataAndWhere[0] 被视为更新的数据字段， 而 dataAndWhere[1:] 被视为 WHERE 条件字段。 另请参阅 Model.Data 和 Model.Where 函数。

func (*Model) X更新减量 ¶

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

Decrement 函数用于对某一列的值减去指定的数量。 参数 `amount` 可以是浮点数或整数类型。

func (*Model) X更新增量 ¶

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

Increment 通过给定的量增加列的值。 参数 `amount` 可以是浮点数或整数类型。

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

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

UpdateAndGetAffected 执行更新语句并返回受影响的行数。

func (*Model) X条件 ¶

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

Where 为生成器设置条件语句。参数`where`可以是以下类型： string/map/gmap/slice/struct/*struct 等等。请注意，如果多次调用， 多个条件将会通过 "AND" 连接符合并到 where 语句中。 参见 WhereBuilder.Where 。

func (*Model) X条件NULL值 ¶

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

WhereNull 构建 `columns[0] IS NULL AND columns[1] IS NULL ...` 语句。 参见 WhereBuilder.WhereNull 方法。

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

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

WherePrefixNull 用于构建 `prefix.columns[0] IS NULL AND prefix.columns[1] IS NULL ...` 语句。 参见 WhereBuilder.WherePrefixNull。

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

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

WhereNotIn 用于构建 `column NOT IN (in)` 语句。 请参阅 WhereBuilder.WhereNotIn。

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

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

WherePrefixNotIn 用于构建 `prefix.column NOT IN (in)` 语句。 请参阅 WhereBuilder.WherePrefixNotIn。

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

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

WhereNot 用于构建 `column != value` 条件语句。 请参阅 WhereBuilder.WhereNot。

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

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

WherePrefixNot 用于构建 `prefix.column != value` 的语句。 参见 WhereBuilder.WherePrefixNot。

func (*Model) X条件包含 ¶

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

WhereIn 构建 `column IN (in)` 语句。 参见 WhereBuilder.WhereIn。

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

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

WherePrefixIn 用于构建 `prefix.column IN (in)` 语句。 参见 WhereBuilder.WherePrefixIn。

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

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

WhereBetween 用于构建 `column BETWEEN min AND max` 语句。 参见 WhereBuilder.WhereBetween。

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

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

WhereNotBetween 用于构建 `column NOT BETWEEN min AND max` 语句。 参见 WhereBuilder.WhereNotBetween。

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

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

WherePrefixNotBetween 用于构建 `prefix.column NOT BETWEEN min AND max` 语句。 参见 WhereBuilder.WherePrefixNotBetween。

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

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

WherePrefixBetween 用于构建 `prefix.column BETWEEN min AND max` 语句。 参见 WhereBuilder.WherePrefixBetween。

func (*Model) X条件大于 ¶

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

WhereGT构建`column > value`语句。 请参阅WhereBuilder.WhereGT。

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

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

WherePrefixGT 用于构建 `prefix.column > value` 语句。 参见 WhereBuilder.WherePrefixGT。

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

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

WhereGTE 用于构建 `column >= value` 条件语句。 参见 WhereBuilder.WhereGTE。

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

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

WherePrefixGTE 用于构建 `prefix.column >= value` 条件语句。 请参阅 WhereBuilder.WherePrefixGTE。

func (*Model) X条件小于 ¶

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

WhereLT构建`column < value`表达式语句。 参见WhereBuilder.WhereLT。

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

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

WherePrefixLT 用于构建 `prefix.column < value` 语句。 请参阅 WhereBuilder.WherePrefixLT。

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

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

WhereLTE 用于构建 `column <= value` 条件语句。 参见 WhereBuilder.WhereLTE。

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

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

WherePrefixLTE 用于构建 `prefix.column <= value` 条件语句。 参见 WhereBuilder.WherePrefixLTE。

func (*Model) X条件带前缀 ¶

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

WherePrefix 的行为类似于 Where，但它会在 where 语句中的每个字段前添加前缀。 请参阅 WhereBuilder.WherePrefix。

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

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

WherePri 执行的逻辑与 Model.Where 相同，但区别在于：如果参数 `where` 是一个单一条件，如 int、string、float 或 slice 类型， 那么它会将这个条件视为主键值。也就是说，如果主键是 "id"，给定的 `where` 参数为 "123"，那么 WherePri 函数会把条件当作 "id=123" 处理， 但是 Model.Where 函数会将该条件当作字符串 "123" 处理。 请参阅 WhereBuilder.WherePri。

func (*Model) X条件或 ¶

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

WhereOr 向 WHERE 语句添加“OR”条件。 请参阅 WhereBuilder.WhereOr。

func (*Model) X条件或NULL值 ¶

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

WhereOrNull 用于构建以 `OR` 条件连接的 `columns[0] IS NULL OR columns[1] IS NULL ...` 语句。 请参阅 WhereBuilder.WhereOrNull。

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

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

WhereOrPrefixNull 用于构建在`OR`条件中的 `prefix.columns[0] IS NULL OR prefix.columns[1] IS NULL ...` 语句。 参见 WhereBuilder.WhereOrPrefixNull。

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

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

WhereOrNotIn 用于构建 `column NOT IN (in)` 语句。 参见 WhereBuilder.WhereOrNotIn。

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

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

WhereOrPrefixNotIn 用于构建 `prefix.column NOT IN (in)` 语句。 请参阅 WhereBuilder.WhereOrPrefixNotIn。

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

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

WhereOrNot 用于构建 `column != value` 的语句。 参见 WhereBuilder.WhereOrNot。

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

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

WhereOrPrefixNot 在`OR`条件中构建 `prefix.column != value` 语句。 参见 WhereBuilder.WhereOrPrefixNot。

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

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

WhereOrIn 在`OR`条件下构建`column IN (in)`语句。 参见WhereBuilder.WhereOrIn方法。

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

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

WhereOrPrefixIn 在`OR`条件中构建 `prefix.column IN (in)` 语句。 参见 WhereBuilder.WhereOrPrefixIn。

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

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

WhereOrBetween 在“OR”条件下构建 `column BETWEEN min AND max` 语句。 参见 WhereBuilder.WhereOrBetween。

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

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

WhereOrNotBetween 用于构建 `column NOT BETWEEN min AND max` 语句，并将其以 `OR` 条件形式加入到查询中。 参考 WhereBuilder.WhereOrNotBetween。

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

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

WhereOrPrefixNotBetween 在“OR”条件下构建 `prefix.column NOT BETWEEN min AND max` 语句。 参见 WhereBuilder.WhereOrPrefixNotBetween。

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

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

WhereOrPrefixBetween 用于构建在“OR”条件中的 `prefix.column BETWEEN min AND max` 语句。 参见 WhereBuilder.WhereOrPrefixBetween。

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

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

WhereOrGT 用于构建 `column > value` 条件语句，并以 `OR` 连接。 详情参见 WhereBuilder.WhereOrGT。

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

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

WhereOrPrefixGT 用于构建 `prefix.column > value` 形式的表达式，并将其以 `OR` 条件的方式加入到语句中。 详情请参阅 WhereBuilder.WhereOrPrefixGT。

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

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

WhereOrGTE 用于构建在“OR”条件中的`column >= value`语句。 参见WhereBuilder.WhereOrGTE。

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

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

WhereOrPrefixGTE 用于构建 `prefix.column >= value` 形式的 OR 条件语句。 请参考 WhereBuilder.WhereOrPrefixGTE。

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

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

WhereOrLT 用于构建在“OR”条件中的 `column < value` 语句。 请参阅 WhereBuilder.WhereOrLT。

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

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

WhereOrPrefixLT 用于构建 `prefix.column < value` 形式的表达式，并将其以 `OR` 条件方式组合。 详情请参阅 WhereBuilder.WhereOrPrefixLT 方法。

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

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

WhereOrLTE 用于构建 `column <= value` 条件语句，并以 `OR` 连接。 // 详情请参考 WhereBuilder.WhereOrLTE 。

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

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

WhereOrPrefixLTE 用于构建 `prefix.column <= value` 形式的 OR 条件语句。 请参阅 WhereBuilder.WhereOrPrefixLTE 方法。

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

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

WhereOrPrefix 执行的功能与 WhereOr 相同，但会在 where 语句中的每个字段前添加指定的前缀。 请参阅 WhereBuilder.WhereOrPrefix。

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

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

WhereOrf 通过 fmt.Sprintf 和参数构建 `OR` 条件字符串。 参见 WhereBuilder.WhereOrf 。

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

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

WhereOrLike 用于构建 `column LIKE like` 语句并在 `OR` 条件中使用。 参考 WhereBuilder.WhereOrLike。

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

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

WhereOrNotLike 用于构建在“OR”条件中的`column NOT LIKE 'like'`语句。 参见 WhereBuilder.WhereOrNotLike。

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

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

WhereOrPrefixNotLike 用于构建 `prefix.column NOT LIKE like` 语句并在 `OR` 条件中使用。 参见 WhereBuilder.WhereOrPrefixNotLike。

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

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

WhereOrPrefixLike 在“OR”条件下构建 `prefix.column LIKE like` 语句。 参见 WhereBuilder.WhereOrPrefixLike。

func (*Model) X条件或非Null ¶

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

WhereOrNotNull 用于构建在`OR`条件中的`columns[0] IS NOT NULL OR columns[1] IS NOT NULL ...`语句。 参见WhereBuilder.WhereOrNotNull方法。

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

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

WhereOrPrefixNotNull 用于构建在`OR`条件中的 `prefix.columns[0] IS NOT NULL OR prefix.columns[1] IS NOT NULL ...` 语句。 参见 WhereBuilder.WhereOrPrefixNotNull。

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

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

Wheref 通过 fmt.Sprintf 和参数构建条件字符串。 注意，如果 `args` 的数量大于 `format` 中的占位符数量， 额外的 `args` 将作为 Model 的 where 条件参数使用。 参见 WhereBuilder.Wheref。

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

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

WhereLike 用于构建 `column LIKE like` 语句。 参见 WhereBuilder.WhereLike。

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

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

WhereNotLike 用于构建 `column NOT LIKE like` 语句。 参见 WhereBuilder.WhereNotLike。

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

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

WherePrefixNotLike 用于构建 `prefix.column NOT LIKE like` 语句。 参见 WhereBuilder.WherePrefixNotLike。

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

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

WherePrefixLike 用于构建 `prefix.column LIKE like` 语句。 参见 WhereBuilder.WherePrefixLike。

func (*Model) X条件非Null ¶

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

WhereNotNull 用于构建 `columns[0] IS NOT NULL AND columns[1] IS NOT NULL ...` 语句。 请参考 WhereBuilder.WhereNotNull。

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

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

WherePrefixNotNull 用于构建 `prefix.columns[0] IS NOT NULL AND prefix.columns[1] IS NOT NULL ...` 形式的语句。 请参阅 WhereBuilder.WherePrefixNotNull。

func (*Model) X查询 ¶

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

All 方法执行针对模型的 "SELECT FROM ..." 语句。 它从表中检索记录并以切片类型返回结果。 如果根据给定条件未能从表中检索到任何记录，则返回 nil。

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

func (*Model) X查询一条 ¶

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

One 从表中检索一条记录并以map类型返回结果。 如果根据给定条件没有从表中检索到任何记录，则返回nil。

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

func (*Model) X查询一条值 ¶

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

Value 从表中检索指定记录的值并以 interface 类型返回结果。 如果根据给定条件在表中未找到记录，则返回 nil。

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

func (*Model) X查询与行数 ¶

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

AllAndCount 从模型中检索所有记录以及记录的总数。 如果 useFieldForCount 设为 true，它将使用模型中指定的字段进行计数； 否则，它将以常数值 1 进行计数。 它以记录切片的形式返回结果、记录的总数量以及（如有）错误信息。 where 参数是一个可选的条件列表，在检索记录时使用这些条件。

示例：

var model Model   // 假设 Model 是自定义的数据模型
var result Result // 假设 Result 是存储查询结果的数据结构
var count int
where := []interface{}{"name = ?", "John"} // 设置查询条件：name 等于 "John"
result, count, err := model.AllAndCount(true) // 调用 AllAndCount 方法并传入参数 useFieldForCount 为 true
if err != nil {

// 处理错误

}
fmt.Println(result, count) // 输出查询结果和记录总数

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

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

ScanAndCount 扫描满足给定条件的单个记录或记录数组，并计算匹配这些条件的记录总数。 如果 useFieldForCount 为 true，则会使用模型中指定的字段进行计数； pointer 参数是一个指向结构体的指针，扫描的数据将存储在这个结构体中。 pointerCount 参数是一个指向整数的指针，该整数将被设置为匹配给定条件的总记录数。 where 参数是可选的检索记录时使用的条件列表。 示例：

var count int
user := new(User)
err  := db.Model("user").Where("id", 1).ScanAndCount(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").
	ScanAndCount(&users, &count, false) // 对于计数不考虑特定字段，因此设为 false

此函数用于根据提供的条件执行数据库查询，同时获取满足条件的记录数量。当 `useFieldForCount` 设为 `true` 时，计数会基于模型中定义的某些字段；否则，计数的是所有满足条件的记录条数。查询结果可以填充到传入的结构体实例（单例或切片）中，同时返回满足条件的记录总数。

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

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

ScanList 将 `r` 转换为包含其他复杂结构体属性的结构体切片。 注意，参数 `listPointer` 应该是指向 []struct 或 []*struct 类型的指针。 参考关联模型: https://goframe.org/pages/viewpage.action?pageId=1114326

参见 Result.ScanList。

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

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

Scan 根据参数 `pointer` 的类型自动调用 Struct 或 Structs 函数。 若 `pointer` 类型为 *struct/**struct，则调用 doStruct 函数。 若 `pointer` 类型为 *[]struct/*[]*struct，则调用 doStructs 函数。 可选参数 `where` 与 Model.Where 函数的参数相同，具体可参考 Model.Where。 注意：如果给定的参数 `pointer` 指向一个具有默认值的变量，并且根据给定条件未能从表中检索到任何记录时， 此函数将返回 sql.ErrNoRows 错误。 示例： 创建一个新的 User 实例 user := new(User) 使用查询条件从 "user" 表中扫描数据并赋值给 user err := db.Model("user").Where("id", 1).Scan(user) 创建一个空指针类型的 User 实例 user := (*User)(nil) 使用查询条件从 "user" 表中扫描数据并赋值给 user err := db.Model("user").Where("id", 1).Scan(&user) 创建一个空切片类型的 User 实例 users := ([]User)(nil) 从 "user" 表中扫描数据并将其填充到 users 切片 err := db.Model("user").Scan(&users) 创建一个空指针切片类型的 User 实例 users := ([]*User)(nil) 从 "user" 表中扫描数据并将其填充到 users 指针切片 err := db.Model("user").Scan(&users)

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

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

CountColumn 对模型执行 "SELECT COUNT(x) FROM ..." 语句。

func (*Model) X查询平均值 ¶

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

Avg 对模型执行 "SELECT AVG(x) FROM ..." 语句，计算平均值。

func (*Model) X查询数组 ¶

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

从数据库查询并以切片形式返回数据值。 注意，如果结果中有多个列，则随机返回其中一个列的值。

如果提供可选参数`fieldsAndWhere`，则fieldsAndWhere[0]表示选定的字段， 而fieldsAndWhere[1:]被视为where条件字段。 同时参阅Model.Fields和Model.Where函数。

func (*Model) X查询最大值 ¶

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

Max 为给定的模型执行“SELECT MAX(x) FROM ...”语句。

func (*Model) X查询最小值 ¶

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

Min 为该模型执行“SELECT MIN(x) FROM ...”语句。

func (*Model) X查询求和 ¶

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

Sum 对模型执行 "SELECT SUM(x) FROM ..." 语句，计算求和。

func (*Model) X查询行数 ¶

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

Count 对模型执行 "SELECT COUNT(x) FROM ..." 语句。 可选参数 `where` 与 Model.Where 函数的参数相同， 请参阅 Model.Where。

func (*Model) X禁用时间自动更新特性 ¶

func (m *Model) X禁用时间自动更新特性() *Model

Unscoped 禁用在插入、更新和删除选项时自动更新时间的特性。

func (*Model) X缓存 ¶

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

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

注意，如果模型在事务中执行选择语句时，缓存功能是禁用的。

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

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

DB 设置/更改当前操作的数据库对象。

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

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

Ctx 设置当前操作的上下文。

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

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

TX 设置/更改当前操作的事务。

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

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

Partition sets Partition name. Example: dao.User.Ctx(ctx).Partition（"p1","p2","p3").All()

func (*Model) X设置分组条件 ¶

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

Having 设置模型的 having 子句。 该函数的使用参数与 Where 函数相同。 参见 Where。

func (*Model) X设置分页 ¶

func (m *Model) X设置分页(第几页, 条数 int) *Model

Page 为模型设置分页号。 参数 `page` 的分页从1开始计数。 注意，它与 Limit 函数从0开始为 "LIMIT" 语句设置偏移量有所不同。

func (*Model) X设置去重 ¶

func (m *Model) X设置去重() *Model

Distinct 用于强制查询只返回不重复的结果。

func (*Model) X设置批量操作行数 ¶

func (m *Model) X设置批量操作行数(数量 int) *Model

Batch 设置模型的批量操作数量。

func (*Model) X设置插入冲突不更新字段 ¶

func (m *Model) X设置插入冲突不更新字段(字段名称 ...interface{}) *Model

OnDuplicateEx 设置在列冲突发生时操作的排除列。 在 MySQL 中，此函数用于 "ON DUPLICATE KEY UPDATE" 语句。 参数 `onDuplicateEx` 可以是字符串、映射或切片类型。 示例：

OnDuplicateEx("passport, password") // 传入一个包含列名的字符串 OnDuplicateEx("passport", "password") // 分别指定列名参数

OnDuplicateEx(g.Map{
	  "passport": "",
	  "password": "",
}) // 通过映射传入选定列名和其对应的更新值（此处为空字符串）

func (*Model) X设置插入冲突更新字段 ¶

func (m *Model) X设置插入冲突更新字段(字段名称 ...interface{}) *Model

OnDuplicate 设置在列冲突发生时的操作。 在 MySQL 中，此方法用于“ON DUPLICATE KEY UPDATE”语句。 参数 `onDuplicate` 可以为 string/Raw/*Raw/map/slice 类型。 示例：

OnDuplicate("nickname, age") // 设置当主键重复时更新nickname和age字段 OnDuplicate("nickname", "age") // 同上，以逗号分隔多个字段名

OnDuplicate(g.Map{
	  "nickname": gdb.Raw("CONCAT('name_', VALUES(`nickname`))"), // 使用原始SQL表达式更新nickname字段
})

OnDuplicate(g.Map{
	  "nickname": "passport", // 当主键重复时，将nickname字段的值设置为passport字段的值
}).

func (*Model) X设置数据 ¶

func (m *Model) X设置数据(值 ...interface{}) *Model

Data 设置模型操作的数据。 参数 `data` 可以为 string、map、gmap、slice、struct、*struct 等类型。 注意，如果 `data` 为 map 或 slice 类型，会采用浅值复制的方式来避免在函数内部对原数据进行修改。 示例： Data("uid=10000") Data("uid", 10000) Data("uid=? AND name=?", 10000, "john") Data(g.Map{"uid": 10000, "name":"john"}) Data(g.Slice{g.Map{"uid": 10000, "name":"john"}, g.Map{"uid": 20000, "name":"smith"}})

func (*Model) X设置条数 ¶

func (m *Model) X设置条数(条数或两个数字 ...int) *Model

Limit 为模型设置 "LIMIT" 语句。 参数 `limit` 可以是一个或两个数字，如果传入两个数字， 则为模型设置 "LIMIT limit[0], limit[1]" 语句，否则设置 "LIMIT limit[0]" 语句。

func (*Model) X设置表别名 ¶

func (m *Model) X设置表别名(别名 string) *Model

As 为当前表设置别名名称。

func (*Model) X过滤Nil ¶

func (m *Model) X过滤Nil() *Model

OmitNil 为模型设置 optionOmitNil 选项，该选项会自动过滤数据和参数中的 `nil` 值。 这意味着在处理数据或设置条件时，将忽略值为 nil 的字段。

func (*Model) X过滤Nil数据 ¶

func (m *Model) X过滤Nil数据() *Model

OmitNilData 为模型设置 optionOmitNilData 选项，该选项会自动过滤 `nil` 值的 Data 参数。

func (*Model) X过滤Nil条件 ¶

func (m *Model) X过滤Nil条件() *Model

OmitNilWhere 为模型设置 optionOmitNilWhere 选项，该选项会自动过滤 Where/Having 条件中的 `nil` 值。

func (*Model) X过滤空值 ¶

func (m *Model) X过滤空值() *Model

OmitEmpty 为模型设置 optionOmitEmpty 选项，该选项会自动过滤掉数据和 `empty` 值的参数。 optionOmitEmpty 选项，该选项会自动过滤掉数据和 `empty` 值的

func (*Model) X过滤空值数据 ¶

func (m *Model) X过滤空值数据() *Model

OmitEmptyData 为模型设置 optionOmitEmptyData 选项，该选项会自动过滤`空`值的 Data 参数。

func (*Model) X过滤空值条件 ¶

func (m *Model) X过滤空值条件() *Model

OmitEmptyWhere 为模型设置 optionOmitEmptyWhere 选项，该选项会自动过滤 Where/Having 子句中 `empty` 值的参数。

示例：

Where("id", []int{}).All()             -> SELECT xxx FROM xxx WHERE 0=1 （当id为空数组时，生成一个恒不成立的条件）
Where("name", "").All()                -> SELECT xxx FROM xxx WHERE `name`='' （当name为空字符串时，生成相应空值条件）
OmitEmpty().Where("id", []int{}).All() -> SELECT xxx FROM xxx （在OmitEmpty作用下，忽略空数组id条件，直接执行查询）
OmitEmpty().Where("name", "").All()         -> SELECT xxx FROM xxx （在OmitEmpty作用下，忽略空字符串name条件，直接执行查询）

func (*Model) X链式安全 ¶

func (m *Model) X链式安全(开启 ...bool) *Model

Safe 用于标记该模型为安全或不安全。如果 safe 为 true，则在每次操作完成后都会克隆并返回一个新的模型对象；否则，它会改变当前模型的属性。

func (*Model) X锁写入 ¶

func (m *Model) X锁写入() *Model

LockShared 将锁设置为当前操作的共享模式。

LockUpdate/锁读写 与 LockShared/锁写入 都是用于确保被选中的记录值不能被其它事务更新（上锁）， 两者的区别在于 LockShared/锁写入 不会阻塞其它事务读取被锁定行记录的值， 而 LockUpdate/锁读写 会阻塞其他锁定性读对锁定行的读取（非锁定性读仍然可以读取这些记录，LockShared/锁写入 和 LockUpdate/锁读写 都是锁定性读）。

例子: g.Model("users").Ctx(ctx).Where("votes>?", 100).LockShared().All(); 上面这个查询等价于下面这条 SQL 语句： SELECT * FROM `users` WHERE `votes` > 100 LOCK IN SHARE MODE

func (*Model) X锁读写 ¶

func (m *Model) X锁读写() *Model

LockUpdate 为当前操作设置更新锁。

LockUpdate/锁读写 与 LockShared/锁写入 都是用于确保被选中的记录值不能被其它事务更新（上锁）， 两者的区别在于 LockShared/锁写入 不会阻塞其它事务读取被锁定行记录的值， 而 LockUpdate/锁读写 会阻塞其他锁定性读对锁定行的读取（非锁定性读仍然可以读取这些记录，LockShared/锁写入 和 LockUpdate/锁读写 都是锁定性读）。

例子: g.Model("users").Ctx(ctx).Where("votes>?", 100).LockUpdate().All(); 上面这个查询等价于下面这条 SQL 语句： SELECT * FROM `users` WHERE `votes` > 100 FOR UPDATE

func (Record) X取Map ¶

func (r Record) X取Map() Map

Map 将 `r` 转换为 map[string]interface{} 类型。

func (Record) X取Map类 ¶

func (r Record) X取Map类() *map类.StrAnyMap

GMap 将 `r` 转换为一个 gmap。

func (Record) X取json ¶

func (r Record) X取json() string

Json 将 `r` 转换为 JSON 格式的内容。

func (Record) X取xml ¶

func (r Record) X取xml(根标记 ...string) string

Xml 将`r`转换为XML格式的内容。

func (Record) X取结构体指针 ¶

func (r Record) X取结构体指针(结构体指针 interface{}) error

Struct 将 `r` 转换为结构体。 注意，参数 `pointer` 应为 *struct 或 **struct 类型。

注意，如果 `r` 为空，则返回 sql.ErrNoRows 错误。

func (Record) X是否为空 ¶

func (r Record) X是否为空() bool

IsEmpty 检查并返回 `r` 是否为空。

func (Result) RecordKeyInt ¶

func (r Result) RecordKeyInt(key string) map[int]Record

RecordKeyInt 将 `r` 转换为一个 map[int]Record 类型的映射，其中键由 `key` 指定。

func (Result) RecordKeyStr ¶

func (r Result) RecordKeyStr(key string) map[string]Record

RecordKeyStr 将 `r` 转换为一个 map[string]Record 类型的映射，其中键由 `key` 指定。

func (Result) RecordKeyUint ¶

func (r Result) RecordKeyUint(key string) map[uint]Record

RecordKeyUint 将 `r` 转换为一个 map[uint]Record 类型的映射，其中键由 `key` 指定。

func (Result) Size别名 ¶

func (r Result) Size别名() int

Size 是函数 Len 的别名。

func (Result) X分割 ¶

func (r Result) X分割(数量 int) []Result

Chunk 将一个 Result 切分成多个 Result， 每个数组的大小由 `size` 决定。 最后一块切片可能包含少于 size 个元素。

func (Result) X取Map数组 ¶

func (r Result) X取Map数组() Map数组

List 将 `r` 转换为一个 List。

func (Result) X取json ¶

func (r Result) X取json() string

Json 将 `r` 转换为 JSON 格式的内容。

func (Result) X取xml ¶

func (r Result) X取xml(根标记 ...string) string

Xml 将`r`转换为XML格式的内容。

func (Result) X取字段MapInt ¶

func (r Result) X取字段MapInt(字段名称 string) map[int]Map

MapKeyInt 将 `r` 转换为一个映射 map[int]Map，其中键由 `key` 指定。 （注：这里可能需要上下文信息，对于 `Map` 类型没有明确说明，所以翻译时假设它是一个已知的类型名。如果 `Map` 是自定义类型或有特殊含义，请替换为实际含义。）

func (Result) X取字段MapStr ¶

func (r Result) X取字段MapStr(字段名称 string) map[string]Map

MapKeyStr 将 `r` 转换为一个 map[string]Map 类型的映射，其中的键由 `key` 指定。

func (Result) X取字段MapUint ¶

func (r Result) X取字段MapUint(字段名称 string) map[uint]Map

MapKeyUint 将`r`转换为一个map[uint]Map类型，其中键由`key`指定。

func (Result) X取字段Map泛型类 ¶

func (r Result) X取字段Map泛型类(字段名称 string) map[string]Value

MapKeyValue 将 `r` 转换为一个 map[string]Value，其中键由 `key` 指定。 注意，项值可能为切片类型。

func (Result) X取字段数组 ¶

func (r Result) X取字段数组(字段名称 ...string) []Value

Array 根据指定列字段获取并返回其值作为一个切片。 当列字段只有一个时，参数 `field` 可选。 如果未给出参数 `field`，则默认的 `field` 为 `Result` 中第一项的第一个字段名。

func (Result) X取指针列表 ¶

func (r Result) X取指针列表(结构体切片指针 interface{}, 绑定到结构体属性名称 string, 结构体属性关联 ...string) (错误 error)

ScanList 将 `r` 转换为包含其他复杂结构体属性的结构体切片。 注意，参数 `structSlicePointer` 应该是 *[]struct 或 *[]*struct 类型。 参考关联模型: https://goframe.org/pages/viewpage.action?pageId=1114326

使用示例 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
ScanList(&users, "User")
ScanList(&users, "User", "uid")
ScanList(&users, "UserDetail", "User", "uid:Uid")
ScanList(&users, "UserScores", "User", "uid:Uid")
ScanList(&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
ScanList(&users)
ScanList(&users, "UserDetail", "uid")
ScanList(&users, "UserScores", "uid")

示例代码中的 "User/UserDetail/UserScores" 参数指定了当前结果将绑定的目标属性结构体。

示例代码中的 "uid" 是结果表字段名，而 "Uid" 是关联结构体属性名——而不是目标绑定的属性名。在示例中，它是实体 "Entity" 中 "User" 的属性名 "Uid"。它会根据给定的 `relation` 参数自动计算 HasOne/HasMany 关系。

为了清晰理解此函数，请参考示例或单元测试用例。

func (Result) X取数组结构体指针 ¶

func (r Result) X取数组结构体指针(结构体指针 interface{}) (错误 error)

Structs 将 `r` 转换为结构体切片。 注意参数 `pointer` 应该是指向结构体切片的指针类型，即 *[]struct 或 *[]*struct。

func (Result) X取数量 ¶

func (r Result) X取数量() int

Len 返回结果列表的长度。

func (Result) X是否为空 ¶

func (r Result) X是否为空() bool

IsEmpty 检查并返回 `r` 是否为空。

func (*Sql执行结果) LastInsertId ¶

func (r *Sql执行结果) LastInsertId() (int64, error)

2024-01-21 X取最后插入id() 这个方法不能翻译, 翻译后返回的结构体会导致未实现LastInsertId方法. LastInsertId 返回数据库对命令执行后生成的整数。通常，这个值来自于插入新行时“自动递增”列。并非所有数据库都支持此特性，并且此类语句的语法也各不相同。 另外，请参阅 sql.Result。

func (*Sql执行结果) RowsAffected ¶

func (r *Sql执行结果) RowsAffected() (int64, error)

2024-01-21 X取影响行数(),这个方法不能翻译, 翻译后返回的结构体会导致未实现RowsAffected方法. RowsAffected 返回由更新、插入或删除操作影响的行数。 但请注意，并非所有数据库或数据库驱动程序都支持此功能。 另外，请参阅 sql.Result。

func (*Sql执行结果) X取影响行数PANI ¶

func (r *Sql执行结果) X取影响行数PANI() int64

MustGetAffected 返回受影响的行数，如果发生任何错误，它会触发panic（即程序崩溃）。

func (*Sql执行结果) X取最后插入IdPANI ¶

func (r *Sql执行结果) X取最后插入IdPANI() int64

MustGetInsertId 返回最后一次插入的ID，如果发生任何错误，它会引发panic。

func (*Stmt) Close ¶

func (s *Stmt) Close() error

Close 关闭该语句。

func (*Stmt) ExecContext ¶

func (s *Stmt) ExecContext(ctx context.Context, args ...interface{}) (sql.Result, error)

ExecContext 在给定参数的情况下执行预编译的语句，并返回一个Result，该Result总结了该语句的效果。

func (*Stmt) QueryContext ¶

func (s *Stmt) QueryContext(ctx context.Context, args ...interface{}) (*sql.Rows, error)

QueryContext 执行带有给定参数的预编译查询语句，并将查询结果以 *Rows 类型返回。

func (*Stmt) QueryRow ¶

func (s *Stmt) QueryRow(args ...interface{}) *sql.Row

QueryRow 执行一个预编译的查询语句，同时传入给定的参数。 如果在执行语句过程中发生错误，该错误将在对返回的 *Row 调用 Scan 方法时返回（Scan 方法始终不为 nil）。 如果查询未选择任何行，则 *Row 的 Scan 方法将返回 ErrNoRows 错误。 否则，*Row 的 Scan 方法将扫描所选中的第一行数据，并丢弃其余数据。

示例用法：

var name string // 声明一个字符串变量 name
err := nameByUseridStmt.QueryRow(id).Scan(&name) // 使用预编译的查询语句并传入 id 参数，然后将查询结果扫描到变量 name 中。

func (*Stmt) QueryRowContext ¶

func (s *Stmt) QueryRowContext(ctx context.Context, args ...interface{}) *sql.Row

QueryRowContext 执行一个带有给定参数的预编译查询语句。 如果在执行该语句时发生错误，该错误将在对返回的 *Row 调用 Scan 时返回，且返回的 *Row 始终是非 nil 的。 若查询未选择任何行，则 *Row 的 Scan 将返回 ErrNoRows 错误。 否则，*Row 的 Scan 会扫描第一条被选择的行，并丢弃其余行。

func (*Stmt) X执行 ¶

func (s *Stmt) X执行(参数 ...interface{}) (sql.Result, error)

Exec 执行已准备好的语句，使用给定的参数，并返回一个 Result 对象，该对象总结了该语句的效果。

func (*Stmt) X查询 ¶

func (s *Stmt) X查询(参数 ...interface{}) (*sql.Rows, error)

Query函数通过给定的参数执行预编译查询语句，并将查询结果以*Rows的形式返回。

func (*X基础事务) ExecContext ¶

func (tx *X基础事务) ExecContext(ctx context.Context, sql string, args ...interface{}) (sql.Result, error)

ExecContext 实现了接口函数 Link.ExecContext。

func (*X基础事务) GetAll别名 ¶

func (tx *X基础事务) GetAll别名(sql string, 参数 ...interface{}) (Result, error)

GetAll 从数据库查询并返回数据记录。 2024-01-09 改成别名,功能与tx.Query()重复

func (*X基础事务) IsOnMaster ¶

func (tx *X基础事务) IsOnMaster() bool

IsOnMaster 实现了接口函数 Link.IsOnMaster。

func (*X基础事务) IsTransaction ¶

func (tx *X基础事务) IsTransaction() bool

IsTransaction 实现了接口函数 Link.IsTransaction。

func (*X基础事务) PrepareContext ¶

func (tx *X基础事务) PrepareContext(ctx context.Context, sql string) (*sql.Stmt, error)

PrepareContext 实现了接口函数 Link.PrepareContext。

func (*X基础事务) QueryContext ¶

func (tx *X基础事务) QueryContext(ctx context.Context, sql string, args ...interface{}) (*sql.Rows, error)

QueryContext 实现了接口函数 Link.QueryContext。

func (*X基础事务) X事务 ¶

func (tx *X基础事务) X事务(上下文 context.Context, 回调函数 func(上下文 context.Context, 事务对象 TX) error) (错误 error)

Transaction 通过函数 `f` 包装事务逻辑。如果函数 `f` 返回非空错误，它将回滚事务并返回该错误。若函数 `f` 返回空（nil）错误，它将提交事务并返回空。 注意：在函数 `f` 中不应手动调用 Commit 或 Rollback 方法处理事务，因为这些操作在此函数中已自动完成。

func (*X基础事务) X事务回滚 ¶

func (tx *X基础事务) X事务回滚() error

Rollback 回滚当前事务。 注意，如果当前处在嵌套事务过程中，它会回滚当前事务， 否则，它会回滚整个事务。

func (*X基础事务) X事务开启 ¶

func (tx *X基础事务) X事务开启() error

Begin 开始一个嵌套事务过程。

func (*X基础事务) X事务提交 ¶

func (tx *X基础事务) X事务提交() error

Commit 提交当前事务。 注意，如果它在一个嵌套事务过程中，会释放先前保存的事务点， 否则，它将提交整个事务。

func (*X基础事务) X保存事务点 ¶

func (tx *X基础事务) X保存事务点(事务点名称 string) error

SavePoint 执行 `SAVEPOINT xxx` SQL 语句，用于保存当前事务点。 参数 `point` 指定了将被保存到服务器的事务点名称。

func (*X基础事务) X关联对象 ¶

func (tx *X基础事务) X关联对象(关联结构体 interface{}) *Model

With 类似于 Core.With，但其操作针对事务。 请参阅 Core.With。

原注释未提及with使用方法, 以下摘自Model对象示例,仅供参考. With 启用关联查询，通过给定的属性对象指定开启。 常考"模型关联-静态关联"文档:https://goframe.org/pages/viewpage.action?pageId=7297190 例如，如果给定如下的结构体定义：

type User struct {
	 gmeta.Meta `orm:"table:user"` // 定义表名为 user
	 Id         int           `json:"id"`    // 用户ID
	 Name       string        `json:"name"`   // 用户名
	 UserDetail *UserDetail   `orm:"with:uid=id"` // 关联 UserDetail 表，通过 uid 等于 id 进行关联
	 UserScores []*UserScores `orm:"with:uid=id"` // 关联 UserScores 表，通过 uid 等于 id 进行关联
}

我们可以通过以下方式在属性 `UserDetail` 和 `UserScores` 上启用模型关联操作： db.With(User{}.UserDetail).With(User{}.UserScores).Scan(xxx) 或者： db.With(UserDetail{}).With(UserScores{}).Scan(xxx) 或者： db.With(UserDetail{}, UserScores{}).Scan(xxx)

func (*X基础事务) X创建Model对象 ¶

func (tx *X基础事务) X创建Model对象(表名或结构体 ...interface{}) *Model

Model 类似于 Core.Model，但其在事务上进行操作。 请参阅 Core.Model。

func (*X基础事务) X删除 ¶

func (tx *X基础事务) X删除(表名称 string, 条件 interface{}, 参数 ...interface{}) (sql.Result, error)

Delete 执行针对该表的 "DELETE FROM ... " 语句。

参数 `condition` 可以是字符串、映射（map/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"} 中文注释： Delete 方法用于执行对该数据表执行 "DELETE FROM ... " SQL语句。

参数 `condition` 支持多种类型，如字符串、字典(map/gmap)、数组、结构体、结构体指针等。 通常会结合参数 `args` 使用，例如以下示例： "uid=10000"，（条件为 uid 等于 10000） "uid", 10000 "money>? AND name like ?", 99999, "vip_%" （条件为 money 大于 99999 并且 name 字段匹配 "vip_%"） "status IN (?)", g.Slice{1,2,3} （条件为 status 字段在数组 [1,2,3] 中） "age IN(?,?)", 18, 50 （条件为 age 字段在范围 18 到 50 内） User{ Id : 1, UserName : "john"} （根据结构体定义的字段作为条件）

func (*X基础事务) X原生SQL ¶

func (tx *X基础事务) X原生SQL(原生Sql string, 参数 ...interface{}) *Model

func (*X基础事务) X原生SQL执行 ¶

func (tx *X基础事务) X原生SQL执行(sql string, 参数 ...interface{}) (sql.Result, error)

Exec 在事务上执行非查询操作。 请参阅 Core.Exec.

func (*X基础事务) X原生SQL查询 ¶

func (tx *X基础事务) X原生SQL查询(sql string, 参数 ...interface{}) (结果 Result, 错误 error)

Query 在事务上执行查询操作。 参见 Core.Query.

func (*X基础事务) X原生SQL查询到结构体指针 ¶

func (tx *X基础事务) X原生SQL查询到结构体指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

GetScan 从数据库查询一个或多个记录，并将它们转换为给定的结构体或结构体数组。

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

func (*X基础事务) X原生SQL查询到结构体数组指针 ¶

func (tx *X基础事务) X原生SQL查询到结构体数组指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

GetStructs 从数据库查询记录并将其转换为给定的结构体。 参数`pointer`应为结构体切片的类型：[]struct/[]*struct。

func (*X基础事务) X原生SQL查询单条到结构体指针 ¶

func (tx *X基础事务) X原生SQL查询单条到结构体指针(结构体指针 interface{}, sql string, 参数 ...interface{}) error

GetStruct 从数据库查询一条记录并将其转换为给定的结构体。 参数 `pointer` 应该是指向结构体的指针。

func (*X基础事务) X原生SQL查询单条记录 ¶

func (tx *X基础事务) X原生SQL查询单条记录(sql string, 参数 ...interface{}) (Record, error)

GetOne 从数据库查询并返回一条记录。

func (*X基础事务) X原生SQL查询字段值 ¶

func (tx *X基础事务) X原生SQL查询字段值(sql string, 参数 ...interface{}) (Value, error)

GetValue 从数据库查询并返回字段值。 SQL语句应当只查询数据库中的一个字段，否则它将仅返回结果中的一个字段。

func (*X基础事务) X原生SQL查询字段计数 ¶

func (tx *X基础事务) X原生SQL查询字段计数(sql string, 参数 ...interface{}) (int64, error)

GetCount 从数据库查询并返回计数。

func (*X基础事务) X原生sql取参数预处理对象 ¶

func (tx *X基础事务) X原生sql取参数预处理对象(sql string) (*Stmt, error)

Prepare 函数用于创建一个预编译的语句，以便后续进行查询或执行操作。 从返回的语句中可以并发地执行多个查询或执行操作。 当该语句不再被需要时，调用者必须调用该语句的 Close 方法。

func (*X基础事务) X取DB对象 ¶

func (tx *X基础事务) X取DB对象() DB

GetDB 返回当前事务的 DB。

func (*X基础事务) X取上下文对象 ¶

func (tx *X基础事务) X取上下文对象() context.Context

GetCtx 返回当前事务的上下文。

func (*X基础事务) X回滚事务点 ¶

func (tx *X基础事务) X回滚事务点(事务点名称 string) error

RollbackTo 执行 `ROLLBACK TO SAVEPOINT xxx` SQL 语句，用于回滚到指定的保存点。 参数 `point` 指定了先前保存的事务点名称。

func (*X基础事务) X底层取事务对象 ¶

func (tx *X基础事务) X底层取事务对象() *sql.Tx

GetSqlTX 返回当前事务的底层事务对象。

func (*X基础事务) X插入 ¶

func (tx *X基础事务) X插入(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

Insert 执行针对该表的 "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` 指定了批量操作的数量。

func (*X基础事务) X插入并取ID ¶

func (tx *X基础事务) X插入并取ID(表名称 string, 值 interface{}, 批量操作行数 ...int) (int64, error)

InsertAndGetId 执行插入操作，并返回自动生成的最后一个插入ID。

func (*X基础事务) X插入并更新已存在 ¶

func (tx *X基础事务) X插入并更新已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

Save 执行针对表的 "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` 指定了批量操作的数量。

func (*X基础事务) X插入并替换已存在 ¶

func (tx *X基础事务) X插入并替换已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

Replace 执行针对该表的 "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` 指定了批量操作的数量。

func (*X基础事务) X插入并跳过已存在 ¶

func (tx *X基础事务) X插入并跳过已存在(表名称 string, 值 interface{}, 批量操作行数 ...int) (sql.Result, error)

InsertIgnore 执行针对表的 "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` 指定批量操作的数量。

func (*X基础事务) X是否已关闭 ¶

func (tx *X基础事务) X是否已关闭() bool

IsClosed 检查并返回此事务是否已提交或回滚。

func (*X基础事务) X更新 ¶

func (tx *X基础事务) X更新(表名称 string, 值 interface{}, 条件 interface{}, 参数 ...interface{}) (sql.Result, error)

Update 执行针对该表的 "UPDATE ... " 语句。

参数 `data` 可以为 string/map/gmap/struct/*struct 等类型。 例如："uid=10000"、"uid", 10000、g.Map{"uid": 10000, "name":"john"}

参数 `condition` 可以为 string/map/gmap/slice/struct/*struct 等类型，通常与参数 `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"} 注：这里的 `g.Map` 和 `g.Slice` 是一种特定的 Go 语言数据结构（可能是自定义类型），分别代表映射和切片。

func (*X基础事务) X设置上下文并取副本 ¶

func (tx *X基础事务) X设置上下文并取副本(上下文 context.Context) TX

Ctx 设置当前事务的上下文。

func (*X组合条件) X取副本 ¶

func (b *X组合条件) X取副本() *X组合条件

Clone 克隆并返回当前 WhereBuilder 的副本。

func (*X组合条件) X条件 ¶

func (b *X组合条件) X条件(条件 interface{}, 参数 ...interface{}) *X组合条件

Where 设置构建器的条件语句。参数`where`可以是以下类型： string/map/gmap/slice/struct/*struct 等等。请注意，如果调用该方法超过一次， 多个条件将会通过使用 "AND" 连接符合并到 where 语句中。 示例： Where("uid=10000") // 设置条件：uid为10000 Where("uid", 10000) // 设置条件：uid为10000 Where("money>? AND name like ?", 99999, "vip_%"）// 设置条件：money大于99999且name字段以"vip_"开头 Where("uid", 1).Where("name", "john") // 设置条件：uid为1且name为"john" Where("status IN (?)", g.Slice{1,2,3}) // 设置条件：status在[1,2,3]范围内 Where("age IN(?,?)", 18, 50) // 设置条件：age在[18,50]范围内 Where(User{ Id : 1, UserName : "john"}) // 设置条件：根据User结构体内容（Id为1，UserName为"john"）

func (*X组合条件) X条件NULL值 ¶

func (b *X组合条件) X条件NULL值(字段名 ...string) *X组合条件

WhereNull 用于构建 `columns[0] IS NULL AND columns[1] IS NULL ...` 语句。

func (*X组合条件) X条件NULL值并带前缀 ¶

func (b *X组合条件) X条件NULL值并带前缀(字段前缀 string, 字段名 ...string) *X组合条件

WherePrefixNull 用于构建如 `prefix.columns[0] IS NULL AND prefix.columns[1] IS NULL ...` 形式的语句。

func (*X组合条件) X条件不包含 ¶

func (b *X组合条件) X条件不包含(字段名 string, 不包含值 interface{}) *X组合条件

WhereNotIn 构造 `column NOT IN (in)` 语句。

func (*X组合条件) X条件不包含并带前缀 ¶

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

WherePrefixNotIn 用于构建 `prefix.column NOT IN (in)` 语句。

func (*X组合条件) X条件不等于 ¶

func (b *X组合条件) X条件不等于(字段名 string, 值 interface{}) *X组合条件

WhereNot 用于构建 `column != value` 的表达式语句。

func (*X组合条件) X条件不等于并带前缀 ¶

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

WherePrefixNot 用于构建 `prefix.column != value` 的表达式语句。

func (*X组合条件) X条件包含 ¶

func (b *X组合条件) X条件包含(字段名 string, 包含值 interface{}) *X组合条件

WhereIn 构建 `column IN (in)` 语句。

func (*X组合条件) X条件包含并带前缀 ¶

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

WherePrefixIn 用于构建 `prefix.column IN (in)` 语句。

func (*X组合条件) X条件取范围 ¶

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

WhereBetween 用于构建 `column BETWEEN min AND max` 语句。

func (*X组合条件) X条件取范围以外 ¶

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

WhereNotBetween 用于构建 `column NOT BETWEEN min AND max` 语句。

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

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

WherePrefixNotBetween 用于构建 `prefix.column NOT BETWEEN min AND max` 的表达式语句。

func (*X组合条件) X条件取范围并带前缀 ¶

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

WherePrefixBetween 用于构建 `prefix.column BETWEEN min AND max` 的语句。

func (*X组合条件) X条件大于 ¶

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

WhereGT 构建 `column > value` 语句。

func (*X组合条件) X条件大于并带前缀 ¶

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

WherePrefixGT 用于构建 `prefix.column > value` 的表达式语句。

func (*X组合条件) X条件大于等于 ¶

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

WhereGTE 用于构建 `column >= value` 的表达式语句。

func (*X组合条件) X条件大于等于并带前缀 ¶

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

WherePrefixGTE 生成 `prefix.column >= value` 语句。

func (*X组合条件) X条件小于 ¶

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

WhereLT 用于构建 `column < value` 语句。

func (*X组合条件) X条件小于并带前缀 ¶

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

WherePrefixLT 用于构建 `prefix.column < value` 的语句。

func (*X组合条件) X条件小于等于 ¶

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

WhereLTE 用于构建 `column <= value` 的表达式语句。

func (*X组合条件) X条件小于等于并带前缀 ¶

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

WherePrefixLTE 用于构建 `prefix.column <= value` 的语句。

func (*X组合条件) X条件带前缀 ¶

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

WherePrefix 的行为类似于 Where，但它会在 where 语句中的每个字段前添加前缀。 示例： WherePrefix("order", "status", "paid") => WHERE `order`.`status`='paid' WherePrefix("order", struct{Status:"paid", Channel:"bank"}) => WHERE `order`.`status`='paid' AND `order`.`channel`='bank'

func (*X组合条件) X条件并识别主键 ¶

func (b *X组合条件) X条件并识别主键(条件 interface{}, 参数 ...interface{}) *X组合条件

WherePri 执行的逻辑与 Model.Where 相同，但有个特殊情况： 如果参数 `where` 是单个条件，如 int、string、float 或 slice 类型， 那么它会将这个条件视为主键值。也就是说，如果主键是 "id"，给定的 `where` 参数为 "123"， 那么 WherePri 函数会将条件处理为 "id=123"； 但是 Model.Where 函数则会将条件处理为字符串 "123"。

func (*X组合条件) X条件或 ¶

func (b *X组合条件) X条件或(条件 interface{}, 参数 ...interface{}) *X组合条件

WhereOr 向 where 语句添加“OR”条件。

func (*X组合条件) X条件或NULL值 ¶

func (b *X组合条件) X条件或NULL值(字段名 ...string) *X组合条件

WhereOrNull 根据“或”条件构建 `columns[0] IS NULL OR columns[1] IS NULL ...` 语句。

func (*X组合条件) X条件或NULL值并带前缀 ¶

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

WhereOrPrefixNull 在`OR`条件下构建 `prefix.columns[0] IS NULL OR prefix.columns[1] IS NULL ...` 语句。

func (*X组合条件) X条件或不包含 ¶

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

WhereOrNotIn 用于构建 `column NOT IN (in)` 语句。

func (*X组合条件) X条件或不包含并带前缀 ¶

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

WhereOrPrefixNotIn 用于构建 `prefix.column NOT IN (in)` 语句。

func (*X组合条件) X条件或不等于 ¶

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

WhereOrNot 用于构建在“OR”条件中的“column != value”语句。

func (*X组合条件) X条件或不等于并带前缀 ¶

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

WhereOrPrefixNot 在“OR”条件下构建“prefix.column != value”语句。

func (*X组合条件) X条件或包含 ¶

func (b *X组合条件) X条件或包含(字段名 string, 包含值 interface{}) *X组合条件

WhereOrIn 在“OR”条件中构建“column IN (in)”语句。

func (*X组合条件) X条件或包含并带前缀 ¶

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

WhereOrPrefixIn 在“OR”条件下构建 `prefix.column IN (in)` 语句。

func (*X组合条件) X条件或取范围 ¶

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

WhereOrBetween 在`OR`条件下构建 `column BETWEEN min AND max` 语句。

func (*X组合条件) X条件或取范围以外 ¶

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

WhereOrNotBetween 在“OR”条件中构建`column NOT BETWEEN min AND max`语句。

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

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

WhereOrPrefixNotBetween 在“OR”条件下构建 `prefix.column NOT BETWEEN min AND max` 语句。

func (*X组合条件) X条件或取范围并带前缀 ¶

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

WhereOrPrefixBetween 在`OR`条件下构建 `prefix.column BETWEEN min AND max` 语句。

func (*X组合条件) X条件或大于 ¶

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

WhereOrGT 在“OR”条件下构建“column > value”语句。

func (*X组合条件) X条件或大于并带前缀 ¶

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

WhereOrPrefixGT 在“OR”条件下构建 `prefix.column > value` 语句。

func (*X组合条件) X条件或大于等于 ¶

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

WhereOrGTE 在“OR”条件下构建“column >= value”语句。

func (*X组合条件) X条件或大于等于并带前缀 ¶

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

WhereOrPrefixGTE 在“OR”条件下构建“prefix.column >= value”语句。

func (*X组合条件) X条件或小于 ¶

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

WhereOrLT 在“OR”条件中构建“column < value”语句。

func (*X组合条件) X条件或小于并带前缀 ¶

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

WhereOrPrefixLT 在`OR`条件下构建 `prefix.column < value` 语句。

func (*X组合条件) X条件或小于等于 ¶

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

WhereOrLTE 用于构建在“OR”条件中的`column <= value`语句。

func (*X组合条件) X条件或小于等于并带前缀 ¶

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

WhereOrPrefixLTE 在`OR`条件下构建 `prefix.column <= value` 语句。

func (*X组合条件) X条件或并带前缀 ¶

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

WhereOrPrefix 的行为类似于 WhereOr，但是它会在 where 语句中的每个字段前添加指定的前缀。 示例： WhereOrPrefix("order", "status", "paid") => WHERE xxx OR (`order`.`status`='已支付') WhereOrPrefix("order", struct{Status:"paid", Channel:"bank"}) => WHERE xxx OR (`order`.`status`='已支付' AND `order`.`channel`='银行')

func (*X组合条件) X条件或格式化 ¶

func (b *X组合条件) X条件或格式化(格式 string, 参数 ...interface{}) *X组合条件

WhereOrf 使用 fmt.Sprintf 和参数构建 `OR` 条件字符串。 Eg: WhereOrf(`amount<? and status=%s`, "paid", 100) => WHERE xxx OR `amount`<100 and status='paid' WhereOrf(`amount<%d and status=%s`, 100, "paid") => WHERE xxx OR `amount`<100 and status='paid'

func (*X组合条件) X条件或模糊匹配 ¶

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

WhereOrLike 在`OR`条件下构建`column LIKE 'like'`语句。

func (*X组合条件) X条件或模糊匹配以外 ¶

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

WhereOrNotLike 在“OR”条件下构建`column NOT LIKE like`语句。

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

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

WhereOrPrefixNotLike 在`OR`条件下构建 `prefix.column NOT LIKE 'like'` 语句。

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

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

WhereOrPrefixLike 在`OR`条件下构建`prefix.column LIKE 'like'`语句。

func (*X组合条件) X条件或非Null ¶

func (b *X组合条件) X条件或非Null(字段名 ...string) *X组合条件

WhereOrNotNull 在`OR`条件下构建 `columns[0] IS NOT NULL OR columns[1] IS NOT NULL ...` 语句。

func (*X组合条件) X条件或非Null并带前缀 ¶

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

WhereOrPrefixNotNull 用于构建 `prefix.columns[0] IS NOT NULL OR prefix.columns[1] IS NOT NULL ...` 形式的 OR 条件语句。

func (*X组合条件) X条件格式化 ¶

func (b *X组合条件) X条件格式化(格式 string, 参数 ...interface{}) *X组合条件

Wheref 通过 fmt.Sprintf 和参数构建条件字符串。 注意，如果 `args` 的数量大于 `format` 中的占位符数量， 额外的 `args` 将作为 Model 的 where 条件参数使用。 示例： Wheref(`amount<? and status=%s`, "paid", 100) => WHERE `amount`<100 and status='paid' Wheref(`amount<%d and status=%s`, 100, "paid") => WHERE `amount`<100 and status='paid'

func (*X组合条件) X条件模糊匹配 ¶

func (b *X组合条件) X条件模糊匹配(字段名 string, 通配符条件值 string) *X组合条件

WhereLike 用于构建 `column LIKE like` 语句。

func (*X组合条件) X条件模糊匹配以外 ¶

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

WhereNotLike 构建 `column NOT LIKE like` 语句。

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

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

WherePrefixNotLike 用于构建 `prefix.column NOT LIKE like` 语句。

func (*X组合条件) X条件模糊匹配并带前缀 ¶

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

WherePrefixLike 用于构建 `prefix.column LIKE like` 语句。

func (*X组合条件) X条件非Null ¶

func (b *X组合条件) X条件非Null(字段名 ...string) *X组合条件

WhereNotNull 用于构建 `columns[0] IS NOT NULL AND columns[1] IS NOT NULL ...` 语句。

func (*X组合条件) X条件非Null并带前缀 ¶

func (b *X组合条件) X条件非Null并带前缀(字段前缀 string, 字段名 ...string) *X组合条件

WherePrefixNotNull 用于构建 `prefix.columns[0] IS NOT NULL AND prefix.columns[1] IS NOT NULL ...` 语句。

func (*X组合条件) X生成条件字符串及参数 ¶

func (b *X组合条件) X生成条件字符串及参数() (条件字符串 string, 参数 []interface{})

Build 函数用于构建当前的 WhereBuilder，并返回条件字符串及参数。