com.dynamic.sql.core

类 AbstractColumnReference

java.lang.Object

com.dynamic.sql.core.AbstractColumnReference

直接已知子类:

ColumnReference

public abstract class AbstractColumnReference
extends Object

该抽象类提供了 SQL 查询列的引用及其相关操作的基础实现。

主要功能包括：

• 选择特定列，支持多种引用方式（如直接字段引用、带表别名的字段引用、自定义列名等）。
• 支持应用聚合函数、窗口函数等高级 SQL 功能，增强查询表达能力。
• 支持嵌套查询列的定义，方便构建复杂查询。
• 支持全列选择（包括所有列或特定表的所有列）。
• 支持与表或公共表表达式（CTE）建立关联关系，灵活定义数据源。

该类作为 SQL 构建的核心抽象部分，开发者可以通过继承该类实现更多高级操作或定制化行为。

注意事项：

• 具体实现需要确保与 SelectSpecification 的状态一致性，以保证查询构建的正确性。
• 某些方法支持条件生效参数（`isEffective`），用于动态控制列的添加，需谨慎使用以避免逻辑错误。
• 已过时的 `columnReference` 方法将在未来版本移除，建议使用 `includeColumns` 替代。

另请参阅:

SelectSpecification

字段概要

字段

限定符和类型	字段和说明
protected SelectSpecification	selectSpecification 维护查询的构建状态和规范。

构造器概要

构造器

限定符	构造器和说明
protected	AbstractColumnReference(SelectSpecification selectSpecification) 构造函数，初始化 SelectSpecification 实例。

方法概要

限定符和类型	方法和说明
abstract AbstractColumnReference	allColumn() 选择所有列。
AbstractColumnReference	allColumn(boolean isEffective) 条件性地选择所有列。
AbstractColumnReference	allColumn(boolean isEffective, Class<?> tableClass) 条件性地选择特定表的所有列。
AbstractColumnReference	allColumn(boolean isEffective, String tableAlias) 条件性地选择指定表别名的所有列。
abstract AbstractColumnReference	allColumn(Class<?> tableClass) 选择特定表的所有列。
abstract AbstractColumnReference	allColumn(String tableAlias) 选择指定表别名的所有列。
AbstractColumnReference	collectionColumn(boolean isEffective, KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty)
abstract AbstractColumnReference	collectionColumn(KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty) 注册一个一对多的字段集合，用于在主表查询中嵌套查询子表的数据并自动组装成集合字段。
abstract AbstractColumnReference	column(AbstractColumFunction iColumFunction) 添加一个函数列到查询中。
abstract AbstractColumnReference	column(AbstractColumFunction iColumFunction, String columnAlias) 添加一个带别名的函数列到查询中。
AbstractColumnReference	column(boolean isEffective, AbstractColumFunction iColumFunction) 条件性地添加一个函数列到查询中。
AbstractColumnReference	column(boolean isEffective, AbstractColumFunction iColumFunction, String columnAlias) 条件性地添加一个带别名的函数列到查询中。
AbstractColumnReference	column(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect, String columnAlias) 条件性地添加一个嵌套查询列到当前查询中。
<T,F> AbstractColumnReference	column(boolean isEffective, FieldFn<T,F> fn, String columnAlias) 条件性地添加一个带别名的列到查询中。
<T,F> AbstractColumnReference	column(boolean isEffective, Fn<T,F> fn) 条件性地添加一个列到查询中。
AbstractColumnReference	column(boolean isEffective, NumberColumn numberColumn) 条件性地添加一个数字列到查询中。
AbstractColumnReference	column(boolean isEffective, String sql) 条件性地添加一个原始 SQL 表达式列到当前查询中。
<T,F> AbstractColumnReference	column(boolean isEffective, String tableAlias, FieldFn<T,F> fn) 条件性地添加一个带有表别名的列到查询中。
<T,F> AbstractColumnReference	column(boolean isEffective, String tableAlias, FieldFn<T,F> fn, String columnAlias) 条件性地添加一个带有表别名和列别名的列到查询中。
AbstractColumnReference	column(boolean isEffective, String tableAlias, String columnName) 条件性地添加一个自定义列到查询中。
AbstractColumnReference	column(boolean isEffective, String tableAlias, String columnName, String columnAlias) 条件性地添加一个带有别名的自定义列到查询中。
AbstractColumnReference	column(boolean isEffective, WindowsFunction windowsFunction, Consumer<Over> over, String columnAlias) 条件性地添加一个窗口函数列到查询中。
abstract AbstractColumnReference	column(Consumer<AbstractColumnReference> nestedSelect, String columnAlias) 添加一个嵌套查询列到当前查询中。
abstract <T,F> AbstractColumnReference	column(FieldFn<T,F> fn, String columnAlias) 添加一个列到查询中，并设置列别名。
abstract <T,F> AbstractColumnReference	column(Fn<T,F> fn) 添加一个列到查询中，使用方法引用指定字段。
abstract AbstractColumnReference	column(NumberColumn numberColumn) 添加一个数字列到查询中。
AbstractColumnReference	column(String sql) 添加一个原始 SQL 表达式列到当前查询中。
abstract <T,F> AbstractColumnReference	column(String tableAlias, FieldFn<T,F> fn) 添加一个带有表别名的列到查询中。
abstract <T,F> AbstractColumnReference	column(String tableAlias, FieldFn<T,F> fn, String columnAlias) 添加一个带有表别名和列别名的列到查询中。
abstract AbstractColumnReference	column(String tableAlias, String columnName) 添加一个自定义列到查询中。
abstract AbstractColumnReference	column(String tableAlias, String columnName, String columnAlias) 添加一个带有别名的自定义列到查询中。
abstract AbstractColumnReference	column(WindowsFunction windowsFunction, Consumer<Over> over, String columnAlias) 添加一个窗口函数列到查询中。
abstract AbstractColumnReference	columnReference(AbstractColumnReference columnReference) 已过时。 该方法将在未来版本删除，请使用 includeColumns(AbstractColumnReference)
abstract AbstractColumnReference	distinct() 添加去重关键字（DISTINCT）到查询中。
AbstractColumnReference	distinct(boolean isEffective) 条件性地添加去重关键字（DISTINCT）到查询中。
abstract <T> TableRelation<T>	from(Class<T> tableClass) 设置查询的主表。
abstract <T> TableRelation<T>	from(Class<T> tableClass, String tableAlias) 设置带有别名的主表。
abstract TableRelation<?>	from(Consumer<AbstractColumnReference> nestedSelect, String tableAlias) 设置嵌套查询作为主表。
abstract TableRelation<?>	from(CteTable cteTable) 设置公共表表达式（CTE）为主表。
abstract <T> TableRelation<T>	from(Supplier<TableFunction> tableFunction, String tableAlias) 设置表函数作为主表。
protected SelectSpecification	getSelectSpecification() 获取当前查询的规范对象。
<T,F> AbstractColumnReference	ignoreColumn(boolean isEffective, Fn<T,F> fn) 条件性地忽略一个列。
abstract <T,F> AbstractColumnReference	ignoreColumn(Fn<T,F> fn) 显式忽略一个列，使其不参与查询结果。
AbstractColumnReference	includeColumns(AbstractColumnReference columnReference) 将指定的列添加到当前查询中。
AbstractColumnReference	includeColumns(boolean isEffective, AbstractColumnReference columnReference) 条件性地将指定的列添加到当前查询中。
AbstractColumnReference	nestColumn(boolean isEffective)

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

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

字段详细资料

selectSpecification

protected final SelectSpecification selectSpecification

维护查询的构建状态和规范。

该字段存储了查询的构建上下文，包括列选择、表关系等信息，确保查询的完整性。

构造器详细资料

AbstractColumnReference

protected AbstractColumnReference(SelectSpecification selectSpecification)

构造函数，初始化 SelectSpecification 实例。

通过传入 SelectSpecification 来初始化查询上下文，所有的列操作都基于此上下文进行。

参数:

selectSpecification - 查询规范对象，用于维护查询状态

方法详细资料

distinct

public abstract AbstractColumnReference distinct()

添加去重关键字（DISTINCT）到查询中。

该方法会将 `DISTINCT` 关键字应用到当前查询的列选择中，确保返回结果中不包含重复记录。

返回:

当前列引用的实例，用于链式调用

distinct

public AbstractColumnReference distinct(boolean isEffective)

条件性地添加去重关键字（DISTINCT）到查询中。

根据 `isEffective` 参数决定是否应用 `DISTINCT` 关键字，仅当 `isEffective` 为 `true` 时生效。

参数:

isEffective - 是否启用去重，`true` 表示启用，`false` 表示忽略

返回:

当前列引用的实例，用于链式调用

column

public abstract <T,F> AbstractColumnReference column(Fn<T,F> fn)

添加一个列到查询中，使用方法引用指定字段。

通过方法引用（`Fn`）选择实体类中的特定字段，添加到查询列列表中。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

fn - 映射函数，用于引用实体类中的字段

返回:

当前列引用的实例，用于链式调用

column

public <T,F> AbstractColumnReference column(boolean isEffective,
                                            Fn<T,F> fn)

条件性地添加一个列到查询中。

根据 `isEffective` 参数决定是否添加字段，仅当 `isEffective` 为 `true` 时生效。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

fn - 映射函数，用于引用实体类中的字段

返回:

当前列引用的实例，用于链式调用

ignoreColumn

public abstract <T,F> AbstractColumnReference ignoreColumn(Fn<T,F> fn)

显式忽略一个列，使其不参与查询结果。

常用于在已经选择了多个列的情况下，排除掉其中某些不需要的列。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

fn - 字段引用函数，通常为实体类的 getter 方法引用

返回:

当前列引用实例，用于链式调用

ignoreColumn

public <T,F> AbstractColumnReference ignoreColumn(boolean isEffective,
                                                  Fn<T,F> fn)

条件性地忽略一个列。

根据 isEffective 参数决定是否忽略字段， 仅当 isEffective 为 true 时才会将指定字段从查询结果中排除。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

isEffective - 是否忽略字段，true 表示忽略，false 表示不做处理

fn - 字段引用函数，通常为实体类的 getter 方法引用

返回:

当前列引用实例，用于链式调用

column

public abstract <T,F> AbstractColumnReference column(String tableAlias,
                                                     FieldFn<T,F> fn)

添加一个带有表别名的列到查询中。

通过指定表别名和方法引用选择字段，适用于多表查询场景。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

tableAlias - 表的别名，用于区分同名字段

fn - 映射函数，用于引用实体类中的字段

返回:

当前列引用的实例，用于链式调用

column

public <T,F> AbstractColumnReference column(boolean isEffective,
                                            String tableAlias,
                                            FieldFn<T,F> fn)

条件性地添加一个带有表别名的列到查询中。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

tableAlias - 表的别名

fn - 映射函数，用于引用实体类中的字段

返回:

当前列引用的实例，用于链式调用

column

public abstract <T,F> AbstractColumnReference column(FieldFn<T,F> fn,
                                                     String columnAlias)

添加一个列到查询中，并设置列别名。

通过方法引用选择字段，并为列指定别名，便于结果映射或查询结果识别。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

fn - 映射函数，用于引用实体类中的字段

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public <T,F> AbstractColumnReference column(boolean isEffective,
                                            FieldFn<T,F> fn,
                                            String columnAlias)

条件性地添加一个带别名的列到查询中。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

fn - 映射函数，用于引用实体类中的字段

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public abstract <T,F> AbstractColumnReference column(String tableAlias,
                                                     FieldFn<T,F> fn,
                                                     String columnAlias)

添加一个带有表别名和列别名的列到查询中。

适用于多表查询场景，通过表别名和列别名明确指定字段。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

tableAlias - 表的别名

fn - 映射函数，用于引用实体类中的字段

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public <T,F> AbstractColumnReference column(boolean isEffective,
                                            String tableAlias,
                                            FieldFn<T,F> fn,
                                            String columnAlias)

条件性地添加一个带有表别名和列别名的列到查询中。

类型参数:

T - 表对应的实体类类型

F - 字段的类型

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

tableAlias - 表的别名

fn - 映射函数，用于引用实体类中的字段

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(String tableAlias,
                                               String columnName)

添加一个自定义列到查询中。

通过指定表别名和列名，适合手动定义列或非实体字段。

参数:

tableAlias - 表的别名

columnName - 列名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      String tableAlias,
                                      String columnName)

条件性地添加一个自定义列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

tableAlias - 表的别名

columnName - 列名

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(String tableAlias,
                                               String columnName,
                                               String columnAlias)

添加一个带有别名的自定义列到查询中。

通过表别名、列名和列别名定义自定义字段。

参数:

tableAlias - 表的别名

columnName - 列名

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      String tableAlias,
                                      String columnName,
                                      String columnAlias)

条件性地添加一个带有别名的自定义列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

tableAlias - 表的别名

columnName - 列名

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(AbstractColumFunction iColumFunction)

添加一个函数列到查询中。

通过 AbstractColumFunction 定义聚合函数或标量函数（如 `SUM`、`ROUND`）。

参数:

iColumFunction - 函数列的定义

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      AbstractColumFunction iColumFunction)

条件性地添加一个函数列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

iColumFunction - 函数列的定义

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(AbstractColumFunction iColumFunction,
                                               String columnAlias)

添加一个带别名的函数列到查询中。

为函数列指定别名，便于结果映射。

参数:

iColumFunction - 函数列的定义

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      AbstractColumFunction iColumFunction,
                                      String columnAlias)

条件性地添加一个带别名的函数列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

iColumFunction - 函数列的定义

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(NumberColumn numberColumn)

添加一个数字列到查询中。

通过 NumberColumn 定义数字相关的列操作。

参数:

numberColumn - 数字列对象

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      NumberColumn numberColumn)

条件性地添加一个数字列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

numberColumn - 数字列对象

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(WindowsFunction windowsFunction,
                                               Consumer<Over> over,
                                               String columnAlias)

添加一个窗口函数列到查询中。

通过 WindowsFunction 和 Over 定义窗口函数（如 `RANK`、`LAG`），并指定窗口定义。

参数:

windowsFunction - 窗口函数实例

over - 窗口定义的消费者，用于配置排序或分区

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      WindowsFunction windowsFunction,
                                      Consumer<Over> over,
                                      String columnAlias)

条件性地添加一个窗口函数列到查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

windowsFunction - 窗口函数实例

over - 窗口定义的消费者，用于配置排序或分区

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public abstract AbstractColumnReference column(Consumer<AbstractColumnReference> nestedSelect,
                                               String columnAlias)

添加一个嵌套查询列到当前查询中。

通过嵌套查询定义一个子查询列，适合复杂查询场景。

参数:

nestedSelect - 嵌套查询的定义，接受一个消费者来构建子查询

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      Consumer<AbstractColumnReference> nestedSelect,
                                      String columnAlias)

条件性地添加一个嵌套查询列到当前查询中。

参数:

isEffective - 是否添加字段，`true` 表示添加，`false` 表示忽略

nestedSelect - 嵌套查询的定义

columnAlias - 列的别名

返回:

当前列引用的实例，用于链式调用

column

public AbstractColumnReference column(String sql)

添加一个原始 SQL 表达式列到当前查询中。

默认始终生效。

示例：

   column("CASE WHEN risk_level = 1 THEN '低' ELSE '高' END AS riskText")
 

参数:

sql - 需要添加的 SQL 表达式，支持别名（如 "xxx AS alias"）

返回:

当前列引用的实例，支持链式调用

column

public AbstractColumnReference column(boolean isEffective,
                                      String sql)

条件性地添加一个原始 SQL 表达式列到当前查询中。

参数:

isEffective - 是否添加该列（true 为添加，false 为忽略）

sql - 需要添加的 SQL 表达式，支持别名（如 "xxx AS alias"）

返回:

当前列引用的实例，支持链式调用

collectionColumn

public AbstractColumnReference collectionColumn(boolean isEffective,
                                                KeyMapping<?,?> keyMapping,
                                                Function<AbstractColumnReference,AbstractColumnReference> valueMapper,
                                                String targetProperty)

collectionColumn

public abstract AbstractColumnReference collectionColumn(KeyMapping<?,?> keyMapping,
                                                         Function<AbstractColumnReference,AbstractColumnReference> valueMapper,
                                                         String targetProperty)

注册一个一对多的字段集合，用于在主表查询中嵌套查询子表的数据并自动组装成集合字段。

该方法用于描述一对多的关系映射， 查询结果将自动按主表主键（parentKey）分组，将子表数据（valueMapper 中指定的字段）封装为集合， 并注入到主表 Java 对象的指定属性（targetProperty）中。

参数:

keyMapping - 主表字段与子表字段的映射关系（一般为主键外键的映射），用于分组。

valueMapper - 子表字段的选择器，通过链式调用 column(...) 指定需要查询的子表字段。

targetProperty - 主表实体类中用于接收子表集合的属性名称。

返回:

字段引用构建器，支持链式调用。

nestColumn

public AbstractColumnReference nestColumn(boolean isEffective)

columnReference

@Deprecated
public abstract AbstractColumnReference columnReference(AbstractColumnReference columnReference)

已过时。 该方法将在未来版本删除，请使用 includeColumns(AbstractColumnReference)

添加另一个列引用到当前查询中。

注意：该方法已过时，将在未来版本中移除，建议使用 includeColumns(AbstractColumnReference) 替代。

参数:

columnReference - 另一个列引用实例

返回:

当前列引用的实例，用于链式调用

includeColumns

public AbstractColumnReference includeColumns(AbstractColumnReference columnReference)

将指定的列添加到当前查询中。

将另一个列引用的所有列（通过 ColumnQuery 列表）合并到当前查询中。

参数:

columnReference - 另一个列引用实例

返回:

当前列引用的实例，用于链式调用

另请参阅:

ColumnReference.withColumns()

includeColumns

public AbstractColumnReference includeColumns(boolean isEffective,
                                              AbstractColumnReference columnReference)

条件性地将指定的列添加到当前查询中。

参数:

isEffective - 是否添加列，`true` 表示添加，`false` 表示忽略

columnReference - 另一个列引用实例

返回:

当前列引用的实例，用于链式调用

allColumn

public abstract AbstractColumnReference allColumn()

选择所有列。

添加当前查询的所有列（无条件选择），适用于选择表中的全部字段。

返回:

当前列引用的实例，用于链式调用

allColumn

public AbstractColumnReference allColumn(boolean isEffective)

条件性地选择所有列。

参数:

isEffective - 是否选择所有列，`true` 表示选择，`false` 表示忽略

返回:

当前列引用的实例，用于链式调用

allColumn

public abstract AbstractColumnReference allColumn(Class<?> tableClass)

选择特定表的所有列。

根据指定的实体类选择表中的所有列。

参数:

tableClass - 表对应的实体类

返回:

当前列引用的实例，用于链式调用

allColumn

public AbstractColumnReference allColumn(boolean isEffective,
                                         Class<?> tableClass)

条件性地选择特定表的所有列。

参数:

isEffective - 是否选择所有列，`true` 表示选择，`false` 表示忽略

tableClass - 表对应的实体类

返回:

当前列引用的实例，用于链式调用

allColumn

public abstract AbstractColumnReference allColumn(String tableAlias)

选择指定表别名的所有列。

根据表别名选择对应的所有列，适用于多表查询。

参数:

tableAlias - 表别名

返回:

当前列引用的实例，用于链式调用

allColumn

public AbstractColumnReference allColumn(boolean isEffective,
                                         String tableAlias)

条件性地选择指定表别名的所有列。

参数:

isEffective - 是否选择所有列，`true` 表示选择，`false` 表示忽略

tableAlias - 表别名

返回:

当前列引用的实例，用于链式调用

from

public abstract <T> TableRelation<T> from(Class<T> tableClass)

设置查询的主表。

指定实体类作为主表，初始化查询的数据源。

类型参数:

T - 表对应的实体类类型

参数:

tableClass - 表对应的实体类

返回:

TableRelation 对象，用于定义表关系

from

public abstract <T> TableRelation<T> from(Class<T> tableClass,
                                          String tableAlias)

设置带有别名的主表。

指定实体类和表别名作为主表，适用于多表或别名查询。

类型参数:

T - 表对应的实体类类型

参数:

tableClass - 表对应的实体类

tableAlias - 表别名

返回:

TableRelation 对象，用于定义表关系

from

public abstract <T> TableRelation<T> from(Supplier<TableFunction> tableFunction,
                                          String tableAlias)

设置表函数作为主表。

通过 TableFunction 和别名定义动态表，适合复杂查询。

类型参数:

T - 表对应的实体类类型

参数:

tableFunction - 表函数的供应商

tableAlias - 表别名

返回:

TableRelation 对象，用于定义表关系

from

public abstract TableRelation<?> from(CteTable cteTable)

设置公共表表达式（CTE）为主表。

使用 CteTable 定义 CTE 作为查询的数据源。

参数:

cteTable - 公共表表达式对象

返回:

TableRelation 对象，用于定义表关系

from

public abstract TableRelation<?> from(Consumer<AbstractColumnReference> nestedSelect,
                                      String tableAlias)

设置嵌套查询作为主表。

通过嵌套查询定义子查询作为主表，适合复杂数据源。

参数:

nestedSelect - 嵌套查询的定义，接受一个消费者来构建子查询

tableAlias - 嵌套查询的别名

返回:

TableRelation 对象，用于定义表关系

getSelectSpecification

protected SelectSpecification getSelectSpecification()

获取当前查询的规范对象。

提供对 SelectSpecification 的访问，便于内部状态管理。

返回:

当前查询的规范对象