TableRelation (dynamic-sql2 0.0.1 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<Condition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`fullJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`fullJoin(CteTable cte, Consumer<Condition> onCondition)` 构建一个 FULL JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
`protected SelectSpecification`	`getSelectSpecification()`
`<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(Consumer<HavingCondition> condition)`
`JoinCondition`	`innerJoin(Class<?> clazz, Consumer<Condition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`innerJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`innerJoin(CteTable cte, Consumer<Condition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`innerJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)` 构建一个 INNER JOIN 连接，用于将当前查询与表函数的结果关联。
`JoinCondition`	`leftJoin(Class<?> clazz, Consumer<Condition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`leftJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`leftJoin(CteTable cte, Consumer<Condition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`leftJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)` 构建一个 LEFT JOIN 连接，用于将当前查询与表函数的结果关联。
`Fetchable`	`limit(int limit)` 限制查询返回的行数。
`Fetchable`	`limit(int offset, int limit)` 限制查询返回的行数。
`<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 tableAlias, String columnName)`
`ThenSortOrder<R>`	`orderBy(String tableAlias, String columnName, SortOrder sortOrder)`
`JoinCondition`	`rightJoin(Class<?> clazz, Consumer<Condition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`rightJoin(Class<?> clazz, String alias, Consumer<Condition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
`JoinCondition`	`rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<Condition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
`JoinCondition`	`rightJoin(CteTable cte, Consumer<Condition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
`JoinCondition`	`rightJoin(Supplier<TableFunction> tableFunction, String alias, Consumer<Condition> onCondition)` 构建一个 RIGHT JOIN 连接，用于将当前查询与表函数的结果关联。
`TableRelation<R>`	`where()` 空条件 WHERE，返回无条件的查询上下文。
`TableRelation<R>`	`where(Consumer<WhereCondition> condition)` 追加 WHERE 条件。

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

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

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

- 构造器详细资料
  - TableRelation
```
public TableRelation(SelectSpecification selectSpecification)
```
- 方法详细资料
  - innerJoin
```
public JoinCondition innerJoin(Class<?> clazz,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
    INNER JOIN 返回两个表中满足连接条件的所有记录。如果没有匹配的记录，则不会出现在结果集中。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Class<?> clazz,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与另一个表关联。
    INNER JOIN 返回两个表中满足连接条件的所有记录。如果没有匹配的记录，则不会出现在结果集中。此方法支持指定表别名。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Consumer<AbstractColumnReference> nestedSelect,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(Supplier<TableFunction> tableFunction,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - innerJoin
```
public JoinCondition innerJoin(CteTable cte,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 INNER JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    innerJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Class<?> clazz,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
    LEFT JOIN 返回左表中的所有记录，以及右表中满足连接条件的记录。如果右表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Class<?> clazz,
                              String alias,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与另一个表关联。
    LEFT JOIN 返回左表中的所有记录，以及右表中满足连接条件的记录。如果右表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Consumer<AbstractColumnReference> nestedSelect,
                              String alias,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(Supplier<TableFunction> tableFunction,
                              String alias,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - leftJoin
```
public JoinCondition leftJoin(CteTable cte,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 LEFT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    leftJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Class<?> clazz,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
    RIGHT JOIN 返回右表中的所有记录，以及左表中满足连接条件的记录。如果左表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Class<?> clazz,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与另一个表关联。
    RIGHT JOIN 返回右表中的所有记录，以及左表中满足连接条件的记录。如果左表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Consumer<AbstractColumnReference> nestedSelect,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
    子查询返回的结果集会作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    nestedSelect - 子查询构建器，用于生成临时表
    
    alias - 子查询结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(Supplier<TableFunction> tableFunction,
                               String alias,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与表函数的结果关联。
    表函数的返回值作为临时表参与连接，支持指定别名和 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    tableFunction - 表函数构建器，用于生成临时表
    
    alias - 表函数结果的别名
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - rightJoin
```
public JoinCondition rightJoin(CteTable cte,
                               Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 RIGHT JOIN 连接，用于将当前查询与公共表表达式 (CTE) 结果关联。
    CTE 的返回值作为临时表参与连接，支持 ON 条件。
    
    指定者:
    
    rightJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(Class<?> clazz,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(Class<?> clazz,
                              String alias,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与另一个表关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法支持指定表别名。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    clazz - 需要连接的表对应的实体类
    
    alias - 表的别名，用于在查询中标识该表
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 JoinCondition 实例，用于继续构建查询链
  - fullJoin
```
public JoinCondition fullJoin(CteTable cte,
                              Consumer<Condition> onCondition)
```
    从接口复制的说明: JoinCondition
    
    构建一个 FULL JOIN 连接，用于将当前查询与公共表表达式 (CTE) 的结果关联。
    FULL JOIN 返回左右表中所有记录，以及满足连接条件的记录。如果任一表中没有匹配的记录，则结果集中该部分字段的值为 NULL。此方法用于支持 CTE 作为临时表参与连接。
    
    指定者:
    
    fullJoin 在接口中 JoinCondition
    
    参数:
    
    cte - 公共表表达式实例
    
    onCondition - 用于构建 ON 条件的 Consumer 对象，通过 Condition 接口定义连接条件
    
    返回:
    
    当前查询上下文的 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<WhereCondition> condition)
```
    从接口复制的说明: JoinCondition
    
    追加 WHERE 条件。
    
    指定者:
    
    where 在接口中 JoinCondition
    
    参数:
    
    condition - 用于构建 WHERE 条件的 Consumer 对象
    
    返回:
    
    返回表连接实例
  - limit
```
public Fetchable limit(int offset,
                       int limit)
```
    从接口复制的说明: JoinCondition
    
    限制查询返回的行数。
    
    指定者:
    
    limit 在接口中 JoinCondition
    
    参数:
    
    offset - 跳过的行数
    
    limit - 返回的最大行数
    
    返回:
    
    当前查询构建器的实例
  - limit
```
public Fetchable limit(int limit)
```
    从接口复制的说明: JoinCondition
    
    限制查询返回的行数。
    
    指定者:
    
    limit 在接口中 JoinCondition
    
    参数:
    
    limit - 返回的最大行数
    
    返回:
    
    当前查询构建器的实例
  - 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
```
public final TableRelation<R> groupBy(String tableAlias,
                                      String columnName)
```
  - groupBy
```
public final <T> TableRelation<R> groupBy(String tableAlias,
                                          FieldFn<T,?> fn)
```
  - groupBy
```
public final TableRelation<R> groupBy(GroupFn... groupByFn)
```
  - having
```
public TableRelation<R> having(Consumer<HavingCondition> condition)
```
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(FieldFn<T,F> field)
```
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(String tableAlias,
                                      FieldFn<T,F> field)
```
  - orderBy
```
public <T,F> ThenSortOrder<R> orderBy(String tableAlias,
                                      FieldFn<T,F> field,
                                      SortOrder sortOrder)
```
  - orderBy
```
public ThenSortOrder<R> orderBy(String tableAlias,
                                String columnName)
```
  - orderBy
```
public ThenSortOrder<R> orderBy(String tableAlias,
                                String columnName,
                                SortOrder sortOrder)
```
  - orderBy
```
public ThenSortOrder<R> orderBy(String orderingFragment)
```
  - 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

limit

limit

where

fetch

fetch

groupBy

groupBy

groupBy

groupBy

having

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

orderBy

getSelectSpecification