类的使用
com.dynamic.sql.core.AbstractColumnReference

使用AbstractColumnReference的程序包

程序包	说明
com.dynamic.sql.context
com.dynamic.sql.core
com.dynamic.sql.core.column
com.dynamic.sql.core.column.function
com.dynamic.sql.core.condition
com.dynamic.sql.core.condition.impl.dialect
com.dynamic.sql.core.dml.select
com.dynamic.sql.core.dml.select.build.column
com.dynamic.sql.core.dml.select.build.join
com.dynamic.sql.mapper
com.dynamic.sql.utils

com.dynamic.sql.context中AbstractColumnReference的使用

返回AbstractColumnReference的com.dynamic.sql.context中的方法

限定符和类型	方法和说明
AbstractColumnReference	DefaultSqlContext.select()

com.dynamic.sql.core中AbstractColumnReference的使用

com.dynamic.sql.core中AbstractColumnReference的子类

限定符和类型	类和说明
class	ColumnReference

返回AbstractColumnReference的com.dynamic.sql.core中的方法

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

参数类型为AbstractColumnReference的com.dynamic.sql.core中的方法

限定符和类型	方法和说明
AbstractColumnReference	ColumnReference.columnReference(AbstractColumnReference columnReference) 已过时。
abstract AbstractColumnReference	AbstractColumnReference.columnReference(AbstractColumnReference columnReference) 已过时。 该方法将在未来版本删除，请使用 includeColumns(AbstractColumnReference)
AbstractColumnReference	AbstractColumnReference.includeColumns(AbstractColumnReference columnReference) 将指定的列添加到当前查询中。
AbstractColumnReference	AbstractColumnReference.includeColumns(boolean isEffective, AbstractColumnReference columnReference) 条件性地将指定的列添加到当前查询中。

类型变量类型为AbstractColumnReference的com.dynamic.sql.core中的方法参数

限定符和类型	方法和说明
AbstractColumnReference	AbstractColumnReference.collectionColumn(boolean isEffective, KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty)
AbstractColumnReference	AbstractColumnReference.collectionColumn(boolean isEffective, KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty)
AbstractColumnReference	ColumnReference.collectionColumn(KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty)
AbstractColumnReference	ColumnReference.collectionColumn(KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty)
abstract AbstractColumnReference	AbstractColumnReference.collectionColumn(KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty) 注册一个一对多的字段集合，用于在主表查询中嵌套查询子表的数据并自动组装成集合字段。
abstract AbstractColumnReference	AbstractColumnReference.collectionColumn(KeyMapping<?,?> keyMapping, Function<AbstractColumnReference,AbstractColumnReference> valueMapper, String targetProperty) 注册一个一对多的字段集合，用于在主表查询中嵌套查询子表的数据并自动组装成集合字段。
AbstractColumnReference	AbstractColumnReference.column(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect, String columnAlias) 条件性地添加一个嵌套查询列到当前查询中。
AbstractColumnReference	ColumnReference.column(Consumer<AbstractColumnReference> nestedSelect, String columnAlias)
abstract AbstractColumnReference	AbstractColumnReference.column(Consumer<AbstractColumnReference> nestedSelect, String columnAlias) 添加一个嵌套查询列到当前查询中。
TableRelation<?>	ColumnReference.from(Consumer<AbstractColumnReference> nestedSelect, String selectAlias)
abstract TableRelation<?>	AbstractColumnReference.from(Consumer<AbstractColumnReference> nestedSelect, String tableAlias) 设置嵌套查询作为主表。

com.dynamic.sql.core.column中AbstractColumnReference的使用

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.column中的方法参数

限定符和类型	方法和说明
ColumnArithmetic	ColumnArithmetic.add(Consumer<AbstractColumnReference> nestedSelect) 使用嵌套查询的结果与当前列相加。
ColumnArithmetic	ColumnArithmetic.divide(Consumer<AbstractColumnReference> nestedSelect) 使用嵌套查询的结果与当前列相除。
ColumnArithmetic	ColumnArithmetic.multiply(Consumer<AbstractColumnReference> nestedSelect) 使用嵌套查询的结果与当前列相乘。
ColumnArithmetic	ColumnArithmetic.subtract(Consumer<AbstractColumnReference> nestedSelect) 使用嵌套查询的结果从当前列中减去。

com.dynamic.sql.core.column.function中AbstractColumnReference的使用

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.column.function中的方法参数

限定符和类型	方法和说明
AbstractColumFunction	AbstractColumFunction.add(Consumer<AbstractColumnReference> nestedSelect)
AbstractColumFunction	AbstractColumFunction.divide(Consumer<AbstractColumnReference> nestedSelect)
AbstractColumFunction	AbstractColumFunction.multiply(Consumer<AbstractColumnReference> nestedSelect)
AbstractColumFunction	AbstractColumFunction.subtract(Consumer<AbstractColumnReference> nestedSelect)

com.dynamic.sql.core.condition中AbstractColumnReference的使用

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.condition中的方法参数

限定符和类型	方法和说明
default <T,F> C	NestedCondition.andEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加等于条件，并且运算，右侧值来自嵌套查询。
default C	NestedCondition.andExists(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 EXISTS 条件，并且运算，判断子查询是否存在。
C	NestedCondition.andExists(Consumer<AbstractColumnReference> nestedSelect) 添加 EXISTS 条件，并且运算，判断子查询是否存在。
default <T,F> C	NestedCondition.andGreaterThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.andGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.andIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 IN 条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 IN 条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.andLessThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.andLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于等于条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.andNotEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加不等于条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加不等于条件，并且运算，右侧值来自嵌套查询。
default C	NestedCondition.andNotExists(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT EXISTS 条件，并且运算，判断子查询是否不存在。
C	NestedCondition.andNotExists(Consumer<AbstractColumnReference> nestedSelect) 添加 NOT EXISTS 条件，并且运算，判断子查询是否不存在。
default <T,F> C	NestedCondition.andNotIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT IN 条件，并且运算，右侧值来自嵌套查询。
<T,F> C	NestedCondition.andNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 NOT IN 条件，并且运算，右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加等于条件（OR 运算），右侧值来自嵌套查询。
default C	NestedCondition.orExists(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 EXISTS 条件（OR 运算），判断子查询是否存在。
C	NestedCondition.orExists(Consumer<AbstractColumnReference> nestedSelect) 添加 EXISTS 条件（OR 运算），判断子查询是否存在。
default <T,F> C	NestedCondition.orGreaterThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orGreaterThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加大于等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加大于等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 IN 条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 IN 条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orLessThan(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orLessThanOrEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加小于等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加小于等于条件（OR 运算），右侧值来自嵌套查询。
default <T,F> C	NestedCondition.orNotEqualTo(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加不等于条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加不等于条件（OR 运算），右侧值来自嵌套查询。
default C	NestedCondition.orNotExists(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT EXISTS 条件（OR 运算），判断子查询是否不存在。
C	NestedCondition.orNotExists(Consumer<AbstractColumnReference> nestedSelect) 添加 NOT EXISTS 条件（OR 运算），判断子查询是否不存在。
default <T,F> C	NestedCondition.orNotIn(boolean isEffective, Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 根据条件添加 NOT IN 条件（OR 运算），右侧值来自嵌套查询。
<T,F> C	NestedCondition.orNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect) 添加 NOT IN 条件（OR 运算），右侧值来自嵌套查询。

com.dynamic.sql.core.condition.impl.dialect中AbstractColumnReference的使用

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.condition.impl.dialect中的方法参数

限定符和类型	方法和说明
GenericWhereCondition	GenericWhereCondition.andEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andExists(Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andNotExists(Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.andNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.andNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orExists(Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orGreaterThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orGreaterThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orLessThan(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orLessThanOrEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orNotEqualTo(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orNotExists(Consumer<AbstractColumnReference> nestedSelect)
GenericWhereCondition	GenericWhereCondition.orNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
<T,F> GenericWhereCondition	GenericWhereCondition.orNotIn(Fn<T,F> fn, Consumer<AbstractColumnReference> nestedSelect)

com.dynamic.sql.core.dml.select中AbstractColumnReference的使用

返回AbstractColumnReference的com.dynamic.sql.core.dml.select中的方法

限定符和类型	方法和说明
AbstractColumnReference	Select.loadColumReference()

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.dml.select中的方法参数

限定符和类型	方法和说明
C	HavingCondition.andEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.andNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
JoinCondition	JoinCondition.innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition) 构建一个 INNER JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.innerJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)
default JoinCondition	JoinCondition.join(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)
default JoinCondition	JoinCondition.join(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition) 使用嵌套查询的 INNER JOIN 方法。
default JoinCondition	JoinCondition.leftJoin(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)
JoinCondition	JoinCondition.leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition) 构建一个 LEFT JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.leftJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)
C	HavingCondition.orEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orGreaterThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orGreaterThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orLessThan(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orLessThanOrEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orNotEqualTo(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
C	HavingCondition.orNotIn(AggregateFunction function, Consumer<AbstractColumnReference> nestedSelect)
default JoinCondition	JoinCondition.rightJoin(boolean isEffective, Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)
JoinCondition	JoinCondition.rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition) 构建一个 RIGHT JOIN 连接，用于将当前查询与子查询结果关联。
JoinCondition	TableRelation.rightJoin(Consumer<AbstractColumnReference> nestedSelect, String alias, Consumer<GenericWhereCondition> onCondition)

com.dynamic.sql.core.dml.select.build.column中AbstractColumnReference的使用

返回变量类型为AbstractColumnReference的类型的com.dynamic.sql.core.dml.select.build.column中的方法

限定符和类型	方法和说明
Consumer<AbstractColumnReference>	NestedColumn.getNestedColumnReference()

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.dml.select.build.column中的构造器参数

构造器和说明
NestedColumn(Consumer<AbstractColumnReference> columnReferenceConsumer, String alias)

com.dynamic.sql.core.dml.select.build.join中AbstractColumnReference的使用

返回变量类型为AbstractColumnReference的类型的com.dynamic.sql.core.dml.select.build.join中的方法

限定符和类型	方法和说明
Consumer<AbstractColumnReference>	NestedJoin.getNestedSelect()

类型变量类型为AbstractColumnReference的com.dynamic.sql.core.dml.select.build.join中的构造器参数

构造器和说明
NestedJoin(Consumer<AbstractColumnReference> nestedSelect, String tableAlias)
NestedJoin(JoinTableType joinTableType, Consumer<AbstractColumnReference> nestedSelect, String tableAlias, Consumer<GenericWhereCondition> onCondition)

com.dynamic.sql.mapper中AbstractColumnReference的使用

返回AbstractColumnReference的com.dynamic.sql.mapper中的方法

限定符和类型	方法和说明
AbstractColumnReference	EntityMapper.select() 创建并返回一个 AbstractColumnReference 对象，用于构建 SQL 查询操作 ，并选择所需的列进行检索。

com.dynamic.sql.utils中AbstractColumnReference的使用

类型变量类型为AbstractColumnReference的com.dynamic.sql.utils中的方法参数

限定符和类型	方法和说明
static SqlStatementSelectWrapper	SqlUtils.executeNestedSelect(Consumer<AbstractColumnReference> nestedSelectConsumer)
static SqlStatementSelectWrapper	SqlUtils.executeNestedSelect(NestedMeta nestedMeta, Consumer<AbstractColumnReference> nestedSelectConsumer)
static SqlStatementSelectWrapper	SqlUtils.executeNestedSelect(NestedMeta nestedMeta, Consumer<AbstractColumnReference> nestedSelectConsumer, Map<String,TableAliasMapping> aliasTableMap)