TableRelation (Dynamic-SQL2 0.1.6 API)

java.lang.Object
- com.dynamic.sql.core.dml.select.TableRelation<R>

所有已实现的接口:: Fetchable, JoinCondition

public class TableRelation<R>
extends Object
implements JoinCondition

表关联关系

构造器概要

构造器
构造器和说明

TableRelation(SelectSpecification selectSpecification)

构造器
构造器和说明
`TableRelation(SelectSpecification selectSpecification)`

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`JoinCondition`	`crossJoin(Class<?> clazz)` 构建一个 CROSS JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`crossJoin(CteTable cte)` 构建一个 CROSS JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
`FetchResult<R>`	`fetch()` 获取查询结果，返回 `FetchResult` 单表查询时默认返回表实体类实例化后的对象。
`<T> FetchResult<T>`	`fetch(Class<T> returnClass)` 获取查询结果，返回指定类型的数据。
`JoinCondition`	`fullJoin(Class<?> clazz, Consumer<GenericWhereCondition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`fullJoin(Class<?> clazz, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`fullJoin(CteTable cte, Consumer<GenericWhereCondition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
`protected SelectSpecification`	`getSelectSpecification()`
`TableRelation<R>`	`groupBy(boolean isEffective, ColumFunction... columFunction)`
`<T> TableRelation<R>`	`groupBy(boolean isEffective, FieldFn<T,?>... fnKey)`
`TableRelation<R>`	`groupBy(boolean isEffective, GroupFn... groupByFn)`
`<T> TableRelation<R>`	`groupBy(boolean isEffective, String tableAlias, FieldFn<T,?> fn)`
`TableRelation<R>`	`groupBy(boolean isEffective, String tableAlias, String columnName)`
`TableRelation<R>`	`groupBy(ColumFunction... columFunction)`
`<T> TableRelation<R>`	`groupBy(FieldFn<T,?>... fnKey)`
`TableRelation<R>`	`groupBy(GroupFn... groupByFn)`
`<T> TableRelation<R>`	`groupBy(String tableAlias, FieldFn<T,?> fn)`
`TableRelation<R>`	`groupBy(String tableAlias, String columnName)`
`TableRelation<R>`	`having(boolean isEffective, Consumer<HavingCondition<GenericWhereCondition>> condition)`
`TableRelation<R>`	`having(Consumer<HavingCondition<GenericWhereCondition>> condition)`
`JoinCondition`	`innerJoin(Class<?> clazz, Consumer<GenericWhereCondition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`innerJoin(Class<?> clazz, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`innerJoin(CteTable cte, Consumer<GenericWhereCondition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`innerJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与表函数的结果关联。
`JoinCondition`	`leftJoin(Class<?> clazz, Consumer<GenericWhereCondition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`leftJoin(Class<?> clazz, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`leftJoin(CteTable cte, Consumer<GenericWhereCondition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`leftJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与表函数的结果关联。
`Fetchable`	`limit(boolean isEffective, int limit)`
`Fetchable`	`limit(boolean isEffective, int offset, int limit)`
`Fetchable`	`limit(int limit)` 限制查询返回的行数。
`Fetchable`	`limit(int offset, int limit)` 限制查询返回的行数。
`ThenSortOrder<R>`	`orderBy(AbstractColumFunction iColumFunction)` 使用列函数添加排序，默认排序方式为 `SortOrder.ASC`。
`ThenSortOrder<R>`	`orderBy(AbstractColumFunction iColumFunction, SortOrder sortOrder)` 使用列函数添加排序，并指定排序方式。
`ThenSortOrder<R>`	`orderBy(boolean condition, AbstractColumFunction iColumFunction)` 根据条件使用列函数添加排序，默认排序方式为 `SortOrder.ASC`。
`ThenSortOrder<R>`	`orderBy(boolean condition, AbstractColumFunction iColumFunction, SortOrder sortOrder)` 根据条件使用列函数添加排序，并指定排序方式。
`<T,F> ThenSortOrder<R>`	`orderBy(boolean condition, FieldFn<T,F> field)` 根据条件添加一个升序排序的字段。
`<T,F> ThenSortOrder<R>`	`orderBy(boolean condition, FieldFn<T,F> field, SortOrder sortOrder)` 根据条件添加一个指定排序方式的字段。
`ThenSortOrder<R>`	`orderBy(boolean condition, String orderingFragment)` 添加一个自定义排序片段到 SQL 的 `ORDER BY` 子句中。
`<T,F> ThenSortOrder<R>`	`orderBy(boolean condition, String tableAlias, FieldFn<T,F> field)` 根据条件添加一个带有表别名的升序排序字段。
`<T,F> ThenSortOrder<R>`	`orderBy(boolean condition, String tableAlias, FieldFn<T,F> field, SortOrder sortOrder)` 根据条件添加一个带有表别名和指定排序方式的字段。
`ThenSortOrder<R>`	`orderBy(boolean condition, String columnName, SortOrder sortOrder)` 根据条件添加一个指定列名和排序方式的排序。
`ThenSortOrder<R>`	`orderBy(boolean condition, String tableAlias, String columnName)` 根据条件添加一个带有表别名的列名升序排序。
`ThenSortOrder<R>`	`orderBy(boolean condition, String tableAlias, String columnName, SortOrder sortOrder)` 根据条件添加一个带有表别名和指定排序方式的列名排序。
`<T,F> ThenSortOrder<R>`	`orderBy(FieldFn<T,F> field)` 添加一个升序排序的字段。
`<T,F> ThenSortOrder<R>`	`orderBy(FieldFn<T,F> field, SortOrder sortOrder)` 添加一个指定排序方式的字段。
`ThenSortOrder<R>`	`orderBy(String orderingFragment)` 添加一个自定义排序片段。
`<T,F> ThenSortOrder<R>`	`orderBy(String tableAlias, FieldFn<T,F> field)` 添加一个带有表别名的升序排序字段。
`<T,F> ThenSortOrder<R>`	`orderBy(String tableAlias, FieldFn<T,F> field, SortOrder sortOrder)` 添加一个带有表别名和指定排序方式的字段。
`ThenSortOrder<R>`	`orderBy(String columnName, SortOrder sortOrder)` 添加一个指定列名和排序方式的排序。
`ThenSortOrder<R>`	`orderBy(String tableAlias, String columnName)` 添加一个带有表别名的列名升序排序。
`ThenSortOrder<R>`	`orderBy(String tableAlias, String columnName, SortOrder sortOrder)` 添加一个带有表别名和指定排序方式的列名排序。
`JoinCondition`	`rightJoin(Class<?> clazz, Consumer<GenericWhereCondition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`rightJoin(Class<?> clazz, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`rightJoin(CteTable cte, Consumer<GenericWhereCondition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`rightJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<GenericWhereCondition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与表函数的结果关联。
`TableRelation<R>`	`where()` 空条件 WHERE，返回无条件的查询上下文。
`TableRelation<R>`	`where(boolean isEffective, Consumer<GenericWhereCondition> condition)`
`TableRelation<R>`	`where(Consumer<GenericWhereCondition> condition)` 追加 WHERE 条件。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

从接口继承的方法 com.dynamic.sql.core.dml.select.JoinCondition
crossJoin, crossJoin, fullJoin, fullJoin, fullJoin, innerJoin, join, join, join, join, join, join, join, join, join, join, join, join, leftJoin, leftJoin, leftJoin, leftJoin, leftJoin, rightJoin, rightJoin, rightJoin, rightJoin, rightJoin

从接口继承的方法 com.dynamic.sql.core.dml.select.Fetchable
fetchOriginalMap

- 构造器详细资料
  - TableRelation
```
public TableRelation(SelectSpecification selectSpecification)
```
- 方法详细资料
  - innerJoin
```
public JoinCondition innerJoin(Class<?> clazz,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
    INNER JOIN 返回两个表中满足连接条件的所有记录。如果没有匹配的记录，则不会出现在结果集中。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Class<?> clazz,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
    INNER JOIN 返回两个表中满足连接条件的所有记录。如果没有匹配的记录，则不会出现在结果集中。此方法支持指定表别名。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Consumer<AbstractColumnReference> nestedSelect,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Supplier<TableFunction> tableFunction,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(CteTable cte,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Class<?> clazz,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
    LEFT JOIN 返回左表中的所有记录，以及右表中满足连接条件的记录。如果右表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Class<?> clazz,
                              String alias,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
    LEFT JOIN 返回左表中的所有记录，以及右表中满足连接条件的记录。如果右表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Consumer<AbstractColumnReference> nestedSelect,
                              String alias,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Supplier<TableFunction> tableFunction,
                              String alias,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(CteTable cte,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Class<?> clazz,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
    RIGHT JOIN 返回右表中的所有记录，以及左表中满足连接条件的记录。如果左表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Class<?> clazz,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
    RIGHT JOIN 返回右表中的所有记录，以及左表中满足连接条件的记录。如果左表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Consumer<AbstractColumnReference> nestedSelect,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Supplier<TableFunction> tableFunction,
                               String alias,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(CteTable cte,
                               Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(Class<?> clazz,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(Class<?> clazz,
                              String alias,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(CteTable cte,
                              Consumer<GenericWhereCondition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法用于支持 CTE 作为临时表参与连接。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 GenericWhereCondition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - crossJoin
```
public JoinCondition crossJoin(Class<?> clazz)
```
    从接口复制的说明: JoinCondition
    
    构建一个 CROSS JOIN 连接，用于将当前查询与另一个表关联。
    CROSS JOIN 返回笛卡尔积，即左表和右表中每一条记录的所有组合。通常在没有显式连接条件时使用 CROSS JOIN，或者用于生成测试数据。
    
    指定者:
    
    crossJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - crossJoin
```
public JoinCondition crossJoin(CteTable cte)
```
    从接口复制的说明: JoinCondition
    
    构建一个 CROSS JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
    CROSS JOIN 返回笛卡尔积，即左表和右表中每一条记录的所有组合。此方法适用于使用公共表表达式作为数据源参与笛卡尔积操作的场景。
    
    指定者:
    
    crossJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - where
```
public TableRelation<R> where(Consumer<GenericWhereCondition> condition)
```
    从接口复制的说明: JoinCondition
    
    追加 WHERE 条件。
    
    指定者:
    
    where 在接口中 JoinCondition
    
    参数:
    
    condition - 用于构建 WHERE 条件的 Consumer 对象
    
    返回:
    
    返回表连接实例
  - where
```
public TableRelation<R> where(boolean isEffective,
                              Consumer<GenericWhereCondition> condition)
```
    指定者:
    
    where 在接口中 JoinCondition
  - limit
```
public Fetchable limit(int offset,
                       int limit)
```
    从接口复制的说明: JoinCondition
    
    限制查询返回的行数。
    
    指定者:
    
    limit 在接口中 JoinCondition
    
    参数:
    
    offset - 跳过的行数
    
    limit - 返回的最大行数
    
    返回:
    
    当前查询构建器的实例
  - limit
```
public Fetchable limit(boolean isEffective,
                       int offset,
                       int limit)
```
    指定者:
    
    limit 在接口中 JoinCondition
  - limit
```
public Fetchable limit(int limit)
```
    从接口复制的说明: JoinCondition
    
    限制查询返回的行数。
    
    指定者:
    
    limit 在接口中 JoinCondition
    
    参数:
    
    limit - 返回的最大行数
    
    返回:
    
    当前查询构建器的实例
  - limit
```
public Fetchable limit(boolean isEffective,
                       int limit)
```
    指定者:
    
    limit 在接口中 JoinCondition
  - where
```
public TableRelation<R> where()
```
    从接口复制的说明: JoinCondition
    
    空条件 WHERE，返回无条件的查询上下文。有时可能需要衔接使用，比如在直接调用分组时。
    
    指定者:
    
    where 在接口中 JoinCondition
    
    返回:
    
    返回表连接实例
  - fetch
```
public FetchResult<R> fetch()
```
    从接口复制的说明: Fetchable
    
    获取查询结果，返回 FetchResult
    单表查询时默认返回表实体类实例化后的对象。
    多表查询时强烈推荐声明具体的返回类型this#fetch(Class)，否则编译器可能要求手动强转类型，即使是类型安全的。
    通常情况下，如果编译器没有准确的推断出具体类型（此时引用类型为Object）,则一般会抛出参数状态异常
    
    指定者:
    
    fetch 在接口中 Fetchable
    
    返回:
    
    查询结果的封装，由此方法返回：Fetchable.fetch(Class)
  - fetch
```
public <T> FetchResult<T> fetch(Class<T> returnClass)
```
    从接口复制的说明: Fetchable
    
    获取查询结果，返回指定类型的数据。
    
    指定者:
    
    fetch 在接口中 Fetchable
    
    类型参数:
    
    T - 返回的数据类型
    
    参数:
    
    returnClass - 结果数据类型的 Class 对象
    
    返回:
    
    查询结果的封装 FetchResult
  - groupBy
```
@SafeVarargs
public final <T> TableRelation<R> groupBy(FieldFn<T,?>... fnKey)
```
  - groupBy
```
@SafeVarargs
public final <T> TableRelation<R> groupBy(boolean isEffective,
                                                       FieldFn<T,?>... fnKey)
```
  - groupBy
```
public final TableRelation<R> groupBy(String tableAlias,
                                      String columnName)
```
  - groupBy
```
public final TableRelation<R> groupBy(boolean isEffective,
                                      String tableAlias,
                                      String columnName)
```
  - groupBy
```
public final <T> TableRelation<R> groupBy(String tableAlias,
                                          FieldFn<T,?> fn)
```
  - groupBy
```
public final <T> TableRelation<R> groupBy(boolean isEffective,
                                          String tableAlias,
                                          FieldFn<T,?> fn)
```
  - groupBy
```
public final TableRelation<R> groupBy(GroupFn... groupByFn)
```
  - groupBy
```
public final TableRelation<R> groupBy(boolean isEffective,
                                      GroupFn... groupByFn)
```
  - groupBy
```
public final TableRelation<R> groupBy(ColumFunction... columFunction)
```
  - groupBy
```
public final TableRelation<R> groupBy(boolean isEffective,
                                      ColumFunction... columFunction)
```
  - having
```
public TableRelation<R> having(Consumer<HavingCondition<GenericWhereCondition>> condition)
```
  - having
```
public TableRelation<R> having(boolean isEffective,
                               Consumer<HavingCondition<GenericWhereCondition>> condition)
```
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(FieldFn<T,F> field)
```
    添加一个升序排序的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    field - 要排序的字段
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(boolean condition,
                                      FieldFn<T,F> field)
```
    根据条件添加一个升序排序的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    field - 要排序的字段
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
    添加一个指定排序方式的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    field - 要排序的字段
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(boolean condition,
                                      FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
    根据条件添加一个指定排序方式的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    field - 要排序的字段
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(String tableAlias,
                                      FieldFn<T,F> field)
```
    添加一个带有表别名的升序排序字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    tableAlias - 表别名
    
    field - 要排序的字段
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(boolean condition,
                                      String tableAlias,
                                      FieldFn<T,F> field)
```
    根据条件添加一个带有表别名的升序排序字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    tableAlias - 表别名
    
    field - 要排序的字段
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(String tableAlias,
                                      FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
    添加一个带有表别名和指定排序方式的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    tableAlias - 表别名
    
    field - 要排序的字段
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(boolean condition,
                                      String tableAlias,
                                      FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
    根据条件添加一个带有表别名和指定排序方式的字段。
    
    类型参数:
    
    T - 包含字段的实体类型
    
    F - 字段的类型
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    tableAlias - 表别名
    
    field - 要排序的字段
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(String tableAlias,
                                String columnName)
```
    添加一个带有表别名的列名升序排序。
    
    参数:
    
    tableAlias - 表别名
    
    columnName - 列名
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                String tableAlias,
                                String columnName)
```
    根据条件添加一个带有表别名的列名升序排序。
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    tableAlias - 表别名，可以为 null 表示不指定表别名
    
    columnName - 列名
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(String columnName,
                                SortOrder sortOrder)
```
    添加一个指定列名和排序方式的排序。
    
    参数:
    
    columnName - 列名
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                String columnName,
                                SortOrder sortOrder)
```
    根据条件添加一个指定列名和排序方式的排序。
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    columnName - 列名
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(String tableAlias,
                                String columnName,
                                SortOrder sortOrder)
```
    添加一个带有表别名和指定排序方式的列名排序。
    
    参数:
    
    tableAlias - 表别名，可以为 null 表示不指定表别名
    
    columnName - 列名
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                String tableAlias,
                                String columnName,
                                SortOrder sortOrder)
```
    根据条件添加一个带有表别名和指定排序方式的列名排序。
    
    参数:
    
    condition - 条件是否为真，为真时才添加排序
    
    tableAlias - 表别名，可以为 null 表示不指定表别名
    
    columnName - 列名
    
    sortOrder - 排序方式（升序或降序）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(String orderingFragment)
```
    添加一个自定义排序片段。
    
    参数:
    
    orderingFragment - 自定义排序片段（SQL 字符串）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(AbstractColumFunction iColumFunction)
```
    使用列函数添加排序，默认排序方式为 SortOrder.ASC。
    
    参数:
    
    iColumFunction - 列函数或表达式
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                AbstractColumFunction iColumFunction)
```
    根据条件使用列函数添加排序，默认排序方式为 SortOrder.ASC。
    当 condition 为 false 时，该排序片段不会生效。
    
    参数:
    
    condition - 执行条件，如果为 false 则忽略该排序
    
    iColumFunction - 列函数或表达式
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(AbstractColumFunction iColumFunction,
                                SortOrder sortOrder)
```
    使用列函数添加排序，并指定排序方式。
    
    参数:
    
    iColumFunction - 列函数或表达式
    
    sortOrder - 排序方式（SortOrder.ASC 或 SortOrder.DESC）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                AbstractColumFunction iColumFunction,
                                SortOrder sortOrder)
```
    根据条件使用列函数添加排序，并指定排序方式。
    当 condition 为 false 时，该排序片段不会生效。
    
    参数:
    
    condition - 执行条件，如果为 false 则忽略该排序
    
    iColumFunction - 列函数或表达式
    
    sortOrder - 排序方式（SortOrder.ASC 或 SortOrder.DESC）
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - orderBy
```
public ThenSortOrder<R> orderBy(boolean condition,
                                String orderingFragment)
```
    添加一个自定义排序片段到 SQL 的 ORDER BY 子句中。
    ⚠️ 注意：该方法直接拼接传入的 orderingFragment，不会做任何转义或参数化处理，因此存在 SQL 注入风险。仅推荐在以下场景下使用：
    - 排序字段和排序方向已通过白名单或枚举校验
    - 片段由框架或可信代码生成，而非直接使用用户输入
    示例：
```
 orderBy("user_id DESC")
 orderBy("created_at ASC, id DESC")
 
```
    参数:
    
    orderingFragment - 自定义排序片段
    
    返回:
    
    ThenSortOrder<R> 实例，用于链式调用
  - getSelectSpecification
```
protected SelectSpecification getSelectSpecification()
```

类 TableRelation<R>

构造器概要

方法概要

从类继承的方法 java.lang.Object

从接口继承的方法 com.dynamic.sql.core.dml.select.JoinCondition

从接口继承的方法 com.dynamic.sql.core.dml.select.Fetchable

构造器详细资料

TableRelation

方法详细资料

innerJoin

innerJoin

innerJoin

innerJoin

innerJoin

leftJoin

leftJoin

leftJoin

leftJoin

leftJoin

rightJoin

rightJoin

rightJoin

rightJoin

rightJoin

fullJoin

fullJoin

fullJoin

crossJoin

crossJoin

where

where

limit

limit

limit

limit

where

fetch

fetch

groupBy

groupBy

groupBy

groupBy

groupBy

groupBy

groupBy

groupBy

groupBy

groupBy

having

having

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

getSelectSpecification