
# DSL规则语法组件介绍
DSL规则引擎定义了一套语言语法规范，DSL语法可以描述为："原模板 "=\>"目标模板"的形式，用于将QueryTree与原模板匹配的节点 ，改写成根据目标模板构建的节点。其中模板由：语法关键词 、符号、变量 、函数和约束组成，其组成方式如[图1]所示。
图1匹配模板语法   
![](https://support.huaweicloud.com/distributed-devg-v10-gaussdb/figure/zh-cn_image_0000002620720519.png "点击放大")
 表1DSL规则语法组件介绍 
| 语法组件名称 | 语法组件介绍                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 约束                                                                                                                                                                                                                                                                                                                  |
|:---|:---|:---|
| 语法关键词  | - 关键词名称：对应QueryTree的一部分。如FILTER关键词，表示QueryTree中的约束条件。  - \<\>：表示关键词的类型。如JOIN\<INNER/LEFT\> 表示JOIN中的各种类型。为空表示使用默认类型，默认类型定义请参考[表2]和[表3]中支持类型的相关说明。  - 每个算子用括号进行分装'{''}' 内表示整个语法关键词的内容。每个语法关键词有自己的变量对应QueryTree表达式中对应的成员。如JOIN\<INNER\>{LEFT: RIGHT: ON: }。表示对应逻辑计划中的JOIN表达式，且是INNER JOIN，其中LEFT表示JOIN的左子树，RIGHT表示JOIN的右子树，ON表示JOIN的连接条件。   | - 入口关键词仅支持QUERY关键词。  - 无默认类型的关键词在匹配时，不允许类型为空，否则会在解析阶段报错。              |
| 符号     | - 冒号 ':'：表示解释符。是对算子成员或变量的赋值操作。  - 且'\&\&'：表示递进，也表示需要满足符号连接的所有条件。  - 通配符'\*'：表示全部匹配。                                                                                                                                                                                                                                                                                                                                       | -                                                                                                                                                                                                                                                                                                                   |
| 变量     | DSL提供'$' + var_string的形式表达变量。变量用于在和QueryTree中的表达式进行匹配时，在表达式匹配成功后将变量和表达式形成映射关系，便于后续处理。以JOIN关键词为例： ``` JOIN<INNER>{ LEFT: $l_var: * RIGHT: $r_val: * ON: $cond: * } ``` 其中LEFT: $l_var: \*表示匹配的是JOIN的左子树，变量为$l_var，匹配的是左子树所有表达式，则左子树表达式和$l_var形成映射关系，即$l_var表示左子树的表达式，同理$r_val表示匹配右子树的所有表达式，$cond表示匹配JOIN所有的连接条件。                                                                                                                                                                                                                                                                                                                                                                                                                                                              | -                                                                                                                                                                                                                                                                                                                   |
| 函数     | 函数是规则实现的基础，约束等复杂语义需要使用函数来表示，其包含的内容可参考[表5]和[表6]。 - 约束检查函数主要作用是检查匹配的表达式是否满足约束条件。  - 表达式计算函数则将变量作为输入，计算后输出的结果，会赋值到新声明的变量中记录下来。                                                                                                                                                                                                                                                                                                | - 函数及其入参需要使用'（''）'进行分隔，否则会在解析时报错。  - 函数入参的变量，需要经过映射赋值，否则会在使用时报错。   |
| 约束     | 表示约束检查，当有多个约束条件时，约束函数通过'\&\&'进行拼接，如[图2]所示。满足所有约束时表示条件满足，匹配成功。每一个算子都可以有自己的约束。约束一般由约束函数构成，约束函数请参见[表5]。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | -                                                                                                                                                                                                                                                                                                                   |
   
图2约束表达   
![](https://support.huaweicloud.com/distributed-devg-v10-gaussdb/figure/zh-cn_image_0000002590201010.png "点击放大")
 表2SQL结构关键字 
| 关键字名称   | 模板语法                                                                                                                                                                                                                                                                                    | 支持类型                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 解释                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| QUERY   | ``` QUERY<QUERY_TYPE> { PREPROCESS: ($PREPROCESS) CTE: ($cte_expr: *) PROJECT: ($proj_expr: *) FROM: ($from_expr: *) FILTER: ($filter_expr: *) GROUP: GROUP<> {$group_expr: *} SORT: ($sort_expr: *) LIMIT: LIMIT<> {$limit_expr: *} POSTPROCESS: ($POSTPROCESS) MAINBLOCK: false } ``` | - QUERY_TYPE：支持的SQL命令类型, 当前可选值包括： SELECT、DELETE、UPDATE和INSERT。   - 当未显式指定关键字类型时，表示使用默认类型，匹配所有当前支持的DML类型。作为匹配关键字时，支持多个类型的组合，不同类型间使用'\|'分隔，例如：SELECT\|DELETE。                                                                                                           | 该关键字用于匹配一个完整的QUERY或SUBQUERY结构，其中固有参数如下（以下参数的顺序固定，需要注意的是，所有参数均支持省略，表示不匹配对应参数或执行对应操作）： - PREPROCESS：用于声明构建时执行的前处理操作，例如： ``` /* 从$pro中提取$j表的属性列，将结果与$attr映射，供后续使用 */ PREPROCESS: $attr:(find_attributes $j $pro) ```     - CTE： 匹配CTE。  - PROJECT： 匹配投影列。  - FROM： 匹配FROM表达式，具体可以是普通表、视图、子查询、JOIN等类型。  - FILTER： 匹配过滤条件。  - GROUP： 匹配GROUP BY条件和HAVING条件。  - SORT： 匹配ORDER BY条件。  - LIMIT： 匹配LIMIT和OFFSET条件。  - POSTPROCESS：用于声明构建时执行的后处理操作，例如： ``` /* 删除THIS指代的当前QUERY BLOCK无用的表信息 */ POSTPROCESS: (remove_unused_table THIS) ```   - MAINBLOCK： 用于标识是否为最外层queryblock。   |
| JOIN    | ``` JOIN<JOIN_TYPE> { ALIAS: ($alia: *) LEFT: ($left_expr: *) RIGHT: ($right_expr: *) ON: ($on_expr: *) ONLY_TOP: false RECURSE_MODE($MODE) } ```                                                                                                                                       | - JOIN_TYPE： 支持LEFT JOIN、RIGHT JOIN、INNER JOIN、CROSS JOIN、SEMI JOIN、ANTI JOIN、FULL JOIN几种连接类型。其中对应的可选值如下： LEFT（LEFT JOIN和RIGHT JOIN统一使用该类型描述）、INNER、CROSS、SEMI、ANTI、FULL。   - 该关键字无默认类型，需显式指定类型，否则解析报错。   | 该关键字用于匹配JOIN连接的内容，其中固有参数如下： - ALIAS：JOIN连接的别名。  - LEFT：JOIN连接中的左表达式。  - RIGHT：JOIN连接中的右表达式，当JOIN_TYPE为CROSS时，需要省略该参数。  - ON：JOIN连接中的连接条件，可省略，表示不进行该参数匹配。  - ONLY_TOP：对于多个JOIN连接的场景，仅匹配第一个JOIN节点，不进行递归匹配。其取值为true或false，可省略，省略时使用默认值false。  - RECURSE_MODE：递归模式，支持CURRENTFIRST（前序遍历）、CHILDFIRST（后序遍历）、CURRENTONLY（仅匹配顶层节点）三种方式，可省略，省略时使用默认值CURRENTFIRST。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| GROUP   | ``` GROUP<> { GROUP: ($group_expr: *) FILTER: ($filter_expr: *) GROUPSET: ($groupset_expr: *) } ```                                                                                                                                                                                     | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 该关键字用于匹配一个GROUP BY结构，其中固有参数如下： - GROUP： 匹配GROUP BY条件。  - FILTER： 匹配HAVING条件，可省略，表示不进行该参数匹配。  - GROUPSET： 匹配GROUPSET条件，可省略，表示不进行该参数匹配。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| LIMIT   | ``` LIMIT<> { LIMIT: ($limit_expr: *) OFFSET: ($offset_expr: *) } ```                                                                                                                                                                                                                   | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 该关键字用于匹配一个LIMIT结构，其中固有参数如下： - LIMIT： 匹配LIMIT条件，可省略，表示不进行该参数匹配。  - OFFSET：匹配OFFSET条件，可省略，表示不进行该参数匹配。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| AGG     | ``` AGG<AGG_TYPE> { ARGS: ($exprs: *) DISTINCT: * } ```                                                                                                                                                                                                                                 | - AGG_TYPE： 支持匹配各类系统内置聚集函数，支持同时指定多个值，使用'\|'分隔。   - 该关键字类型不显式指定时，表示使用默认类型，匹配所有AGG类型。                                                                                                                                                                           | 该关键字支持匹配所有AGG函数，并且可以指定type类型匹配具体的AGG函数，如：AGG\<\>表示匹配所有AGG函数；AGG\<MIN\|MAX\>表示匹配min和max类型的AGG函数，其中固有参数如下： - AGG_TYPE：AGG函数类型，如包含多个则使用'\|'进行分隔。AGG函数范围为PG_PROC系统表中存在的聚集函数。  - ARGS：AGG函数的入参。  - DISTINCT：创建AGG函数时用于指定是否添加DISTINCT约束。取值为TRUE或FALSE，默认为FALSE。   说明： AGG关键字匹配支持省略ARGS参数，当该参数省略时，其他参数也必须省略，如下两个场景所示： - 指定AGG_TYPE，匹配AGG_TYPE对应的聚集函数 ``` /* 匹配MIN、MAX及SUM这三种类型的聚集函数 */ AGG<MIN|MAX|SUM> {} ```     - AGG_TYPE省略，匹配所有的聚集函数 ``` AGG<> {} ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| SUBLINK | ``` SUBLINK<SUBLINK_TYPE> { TEST_EXPR: ($test: *) QUERY: ($exprs: *) } ```                                                                                                                                                                                                              | - SUBLINK_TYPE： 支持ANYSUBLINK、NOTANYSUBLINK、ALLSUBLINK、NOTALLSUBLINK、EXISTSSUBLINK、NOTEXISTSSUBLINK、EXPRSUBLINK、ROWCOMPARESUBLINK类型。   - 该关键字无默认类型，需显式指定类型，否则解析报错。                                                                                              | 该关键字用于匹配一个SUBLINK结构，其中固有参数如下： - QUERY：匹配QUERY结构。  - TEST_EXPR: 匹配TEST表达式，仅ANYSUBLINK、NOTANYSUBLINK、ALLSUBLINK、NOTALLSUBLINK、ROWCOMPARESUBLINK类型有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| CROSS   | ``` CROSS<> { ARGS: ($exprs: *) } ```                                                                                                                                                                                                                                                   | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 该关键字用于匹配一个笛卡尔积，其中固有参数如下： ARGS：笛卡尔积的表信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| SET     | ``` SET<SET_TYPE> { LEFT: ($left_expr: *) RIGHT: ($right_expr: *) MATCHTYPE_ALLSAME: * IGNOREUNMATCHTYPE: * } ```                                                                                                                                                                       | - SET_TYPE： 支持UNION、UNIONALL、INTERSECT、INTERSECTALL、EXCEPT、EXCEPTALL类型。   - 作为匹配关键字时，支持多个类型的组合，不同类型间使用'\|'分隔，例如：UNION \| UNIONALL。                                                                                                                                | 该关键字用于匹配一个集合，其中固有参数如下： - LEFT：SET关键字的左表达式。  - RIGHT：SET关键字的右表达式。  - MATCHTYPE_ALLSAME：用于标记是否检查集合中所有操作类型的一致性。当该参数设置为TRUE时，要求集合内所有操作类型必须一致。此参数为可选参数，默认值为TRUE。  - IGNOREUNMATCHTYPE：用于标记是否忽略集合中不支持的操作类型。当该参数设置为TRUE时，允许集合中包含除匹配类型之外的其他操作类型。此参数为可选参数，默认值为FALSE。   说明： SET关键字匹配支持使用通用模板匹配模式，该模式下可以省略RIGHT关键字及其表达式信息。当存在多个子查询时，该模式可一次性匹配所有满足LEFT关键字中表达式的节点，现固定写法如下（MATCHTYPE_ALLSAME采用默认值TRUE，IGNOREUNMATCHTYPE采用默认值FALSE）： ``` SET<xxx> { LEFT: $set_left : QUERY<xxx> {xxx} } ``` 后续可以与FOREACH_NODES_WITH_TEMPLATE函数结合使用，使用方法如下： ``` FOREACH_NODES_WITH_TEMPLATE $set_left (xxx_func） ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| PROJECT | ``` PROJECT<> { ARGS: ($exprs: *) MATCHALL: * } ```                                                                                                                                                                                                                                     | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 该关键字用于匹配投影列信息，其中固有参数如下： - ARGS：投影列表达式。  - MATCHALL：用于标识是否返回全部匹配的投影列。当该参数设置为TRUE时，返回所有与投影类表达式匹配的投影列；设置为FALSE时，仅返回首个匹配的投影列。此参数为可选参数，默认值为TRUE。   说明： PROJECT关键字的固定用法如下，其返回值为批量匹配的投影列信息，MATCHALL省略使用默认值TRUE： ``` $proj:PROJECT<> { ARGS: $exprs: * } ``` 后续可以与FOREACH_NODES_WITH_TEMPLATE函数结合使用，使用方法如下： ``` FOREACH_NODES_WITH_TEMPLATE $proj （xxx_func） ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| CTE     | ``` CTE<$name:*> { QUERY: $CTE_QUERY } ```                                                                                                                                                                                                                                              | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 该关键字用于匹配CTE结构，固有参数如下： - name: CTE名。  - QUERY：匹配QUERY结构。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
   
 表3表达式扩展关键字 
| 关键字名称    | 模板语法                                                                                              | 支持类型                                                                                                                                                                                                                                                                                                                                                                                                                 | 解释                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
|:---|:---|:---|:---|
| OR       | ``` OR<> { ARGS: ($exprs: *) } ```                                                                | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个OR表达式结构，其中固有参数如下： ARGS：OR表达式的内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| AND      | ``` AND<> { ARGS: ($exprs: *) } ```                                                               | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个AND表达式结构，其中固有参数如下： ARGS： AND表达式的内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| NOT      | ``` NOT<> { ARGS: ($exprs: *) } ```                                                               | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个NOT表达式结构，其中固有参数如下： ARGS：NOT表达式的内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| BOOLEAN  | ``` BOOLEAN<BOOLEAN_TYPE> { ARGS: ($exprs: *) IGNORENULL: * AUTOMATCH: * } ```                    | - BOOLEAN_TYPE: 支持AND、OR、NOT三个可选值，支持使用'\|' 进行组合。   - 当未显式指定关键字类型时，表示使用默认类型，匹配所有的BOOL类型。                      | 该关键字用于匹配一个BOOL类型表达式结构，其中固有参数如下： - ARGS：BOOL类型表达式的内容。  - IGNORENULL：当被匹配的表达式为空时，是否视为合法。TRUE表示合法，FALSE表示不合法，默认值：FALSE，可省略，省略时使用默认值FALSE。  - AUTOMATCH：是否从给定的表达式中自动匹配BOOL表达式。TRUE表示自动匹配给定条件中包含的BOOL表达式；FALSE表示给定的表达式必须为一个完整的BOOL表达式，默认值：FALSE，可省略，省略时使用默认值FALSE。   |
| CONST    | ``` CONST<CONST_TYPE> { ARGS: ($exprs: *) } ```                                                   | - CONST_TYPE: 支持INTEGER，BOOL类型。   - 该关键字类型不显式指定时，表示使用默认类型，匹配INTEGER类型。                                    | 该关键字用于匹配CONST表达式内容，其中固有参数如下： ARGS：CONST表达式的内容，可为空。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| NULLTEST | ``` NULLTEST<NULLTEST_TYPE> { ARGS: ($exprs: *) } ```                                             | - NULLTEST_TYPE： 支持ISNULL，NOTNULL类型。   - 该关键字无默认类型，需显式指定类型，否则解析报错。                                     | 该关键字用于匹配一个ISNULL或NOTNULL表达式，其中固有参数如下： ARGS：NULLTEST表达式的内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| OPERATOR | ``` OPERATOR<OPERATOR_TYPE>{ LEFT: ($left_expr: *) RIGHT: ($right_expr: *) IGNORESIDE: true } ``` | - OPERATOR_TYPE： 支持EQ，NE，GT，GE，LT，LE，PLUS类型。支持多个类型的组合，不同类型间使用'\|'分隔。   - 该关键字无默认类型，需显式指定类型，否则解析报错。   | 该关键字用于匹配一个OPERATOR表达式，其中固有参数如下： - LEFT： OPERATOR表达式的左表达式。  - RIGHT： OPERATOR表达式的右表达式。  - IGNORESIDE： 是否忽略左右节点的顺序，可省略，省略时使用默认值TRUE。                                                                                                                              |
| CASE     | ``` CASE<>{ ARGS: ($expr: *) DEFRESULT: ($def: *) } ```                                           | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个CASE表达式，其中固有参数如下： - ARGS： 匹配的表达式。  - DEFRESULT： 默认结果表达式。                                                                                                                                                                                                                                                                                                    |
| WHEN     | ``` WHEN<>{ ARGS: ($expr: *) DEFRESULT: ($def: *) } ```                                           | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个WHEN表达式，其中固有参数如下： - ARGS： 匹配的WHEN条件。  - DEFRESULT： 返回结果表达式。                                                                                                                                                                                                                                                                                            |
| COL      | ``` COL<> { ARGS: ($exprs: *) } ```                                                               | 无类型信息。                                                                                                                                                                                                                                                                                                                                                                                                               | 该关键字用于匹配一个表的属性列表达式，其中固有参数如下： ARGS：COL表达式的内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
   
表4补充关键字 
| 关键字名称       | 模板语法                               | 解释                                                                                                                                                                                                                                                                                                                                                                                                         |
|:---|:---|:---|
| CONSTRAINTS | ``` CONSTRAINTS：/* CONTENT */ ```  | 该关键字用于约束结构关键字或表达式扩展关键字，可以作为[表2]及[表3]包含关键字的最后一个入参使用。示例如下： ``` /* 约束QUERY关键字包含LIMIT子句 */ QUERY<> { PROJECT: $proj:* FILTER: $sub_filter:* CONSTRAINTS: (check_has_constraint THIS LIMIT) } ```                                                             |
| TEMPLATE    | ``` TEMPLATE { /* CONTENT */ } ``` | 该关键字用于约束函数或表达式计算函数的入参，其内容不可以为空，内容可以为结构关键字或表达式扩展关键字，当函数实现需要使用模板而非其构造成的表达式时，可以使用该关键字，各函数支持的关键字参见各函数说明。示例如下： ``` /* find_nodes_with_template使用模板template {DSLSTRUCT}匹配$redundant_info中的相关内容，并将结果映射到$r_info_template，供后续使用，如果DSLSTRUCT不使用TEMPLATE关键字，则会被解析为一个表达式而不是模板 */ $r_info_template: (find_nodes_with_template $redundant_info template {DSLSTRUCT}) ``` |
| THIS        | ``` THIS ```                       | 该关键字用于约束函数或表达式计算函数的入参，指代当前所属范围的QUERY BLOCK。示例如下： ``` /* 删除THIS指代的当前QUERY BLOCK无用的表信息 */ POSTPROCESS: (remove_unused_table THIS) ```                                                                                                                                                                                                                         |
| ROOT        | ``` ROOT ```                       | 该关键字用于约束函数或表达式计算函数的入参，指代第一层的QUERY BLOCK。示例如下： ``` /* 约束ROOT指代第一层QUERY BLOCK包含LIMIT子句 */ CONSTRAINTS: (check_has_constraint ROOT LIMIT) ```                                                                                                                                                                                                                  |
   
 表5约束函数 
| 函数名                      | 函数原型                                                                                                    | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 功能描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|:---|
| CHECK_HAS_CONSTRAINT     | ``` bool check_has_constraint(DSLNode $args, DSLType $flags) ```                                        | - $args： 类型：DSLNode 描述：待检查的DSLNode节点（对应内部实现为QueryTree或者Node节点）。   - $flags： 描述：支持检查的类型标志（仅检查是否存在）如下：VOLATILE（v函数）、STABLE（s函数）、IMMUTE（i函数）、AGG（AGG函数）、WINAGG（窗口函数）、DISTINCT（DISTINCT关键字）、DISTINCT_ON（DISTINCT ON关键字）、ROWNUM（有ROWNUM关键字）、MODIFYCTE（UPDATE等操作类型的CTE表）、LIMIT（LIMIT约束）、OFFSET（LIMIT OFFSET约束）、SET（集合类型）、GROUP（GROUP BY分组）、GROUPSET（GROUPING SETS类型）、HAVING（Having条件）、ROWMARK（FOR Update等有行锁的场景）、CTE（存在CTE列表）、RETURNSET（返回多列的函数类型）、SUBLINK（存在子链接）、PLACEHOLDERVAR（存在PLACEHOLDERVAR）、UNPIVOT（存在行列转换）、UPPERVAR（存在上层参数，一般用于判断是否相关子链接）、SORT（存在ORDER BY排序）、RECURSIVE_CTE（存在递归CTE）、FULLGROUP（表示投影列中表属性列必须在Group中）。                                                                                                                                                                                                                                                                                                               | 检查节点中是否包含待检查的Flags标志，根据返回结果判断是否满足约束条件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| CHECK_IS_SINGLE_TABLE    | ``` bool check_is_single_table(DSLNode $args) ```                                                       | $args： 类型：DSLNode 描述：待检查的DSLNode节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 检查节点中是否为单表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| CHECK_IS_EQUAL           | ``` bool check_is_equal(DSLNode $args1, DSLNode $args2, DSLType $flags) ```                             | - $args1： 类型：DSLNode 描述：待等值检查的DSLNode节点1。   - $args2： 类型：DSLNode 描述：待等值检查的DSLNode节点2。   - $flags： 类型：DSLType 描述：可以选择STRICT或者PHYSIC，该参数可以省略，省略时使用默认值STRICT。 - 当检查类型为STRICT时，待检查的节点相等的要求是所有成员变量均相等。  - 当检查类型为PHYSIC时，当前支持VAR进行该类型的等值比较，需要满足参数来自的表类型相同，表位置相同，参数类型相同即可判断为结构相同。                                                                                                   | 检查节点1和节点2是否满足等值条件。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| CHECK_IS_SUBSET          | ``` bool check_is_subset(List $sub, List $parent) ```                                                   | - $sub： 类型：List 描述：待检查的类型集合。   - $parent： 类型：List 描述：用于检查的父集合。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 判断一个集合是否为另一个集合的子集。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| CONTAIN_ATTR_OF          | ``` bool contain_attr_of(List $args, List $tables) ```                                                  | - $args： 类型：List 描述：待检查的属性列集合。   - $tables： 类型：List 描述：指定的表节点，可以通过FIND_TABLES获取。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 判断是否包含指定表的属性列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| CHECK_TYPE_FOREACH       | ``` bool check_type_foreach(List $arg, DSLType $check_type, DSLType $any_all_type) ```                  | - $arg： 类型：List/DSLNode 描述：待检查的表达式集合。   - $check_type： 类型：DSLType 描述：支持的表达式类型：AND（AND表达式）、OR（OR表达式）、NOT（NOT表达式）、CONST（常数类型）、COUNT_STAR（COUNT(\*)表达式）、SUBQUERY（子查询）、NOTNULL（属性列NOTNULL属性）、COL（为属性列）。   - $any_all_type： 类型：DSLType 描述：可以选择ALL或者ANY，该参数可以省略，省略时使用默认值ALL。 - ALL ，表示所有待检查项均为表达式类型。  - ANY，表示有一个检查项为表达式类型即可。                                                       | 检验待检查表达式类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| CHECK_IS_EMPTY           | ``` bool check_is_empty(DSLNode $arg) ```                                                               | $arg： 类型：DSLNode 描述：待检查的表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 判断表达式是否为空。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| CHECK_CONSTRAINT_FOREACH | ``` bool check_constraint_foreach(List $args, DSLType $flags) ```                                       | - $args： 类型：List 描述：待检查的表集合，可以通过FIND_TABLES获取。   - $flags： 描述：支持检查的类型标志（仅检查是否存在）如下：WINAGG（窗口函数）、DISTINCT（DISTINCT关键字）、DISTINCT_ON（DISTINCT ON关键字）、MODIFYCTE（UPDATE等操作类型的CTE表）、LIMIT（LIMIT约束）、OFFSET（LIMIT OFFSET约束）、SET（集合类型）、GROUP（GROUP BY分组）、GROUPSET（GROUPING SETS类型）、HAVING（Having条件）、ROWMARK（FOR Update等有行锁的场景）、UNPIVOT（存在行列转换）、SORT（存在ORDER BY 排序）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 检查所有表包含待检查的Flags标志。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| CHECK_IS_SAME_TABLE      | ``` bool check_is_same_table(List $args1, List $args2) ```                                              | - $args1： 类型：List 描述：待检查的表集合1，可以通过FIND_TABLES获取。   - $args2： 类型：List 描述：待检查的表集合2，可以通过FIND_TABLES获取。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 检查表集合是否相等。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| CHECK_IS_SIMPLE_COLUMN   | ``` bool check_is_simple_column(List $args1, List $dsl_simple_col_type_list, DSLTpye $any_all_type) ``` | - $args1： 类型：List 描述：待检查的节点集合。   - $dsl_simple_col_type_list： 类型：List 描述：代表允许通过检查的节点类型。 可选值：COL、CONST、DSLEXPR、IGNOREAGG，支持使用'\|' 进行组合。   - $any_all_type： 类型：DSLType 描述：用于指定在检查满足条件的结构体时的行为。 可选值：ALL、ANY。 - ALL ，表示所有待检查项均符合条件时返回true。  - ANY，表示存在一个检查项符合条件时即可返回true。     | 检查列表中的节点是否为指定节点类型： - COL（表的单个属性列）。  - CONST（单个常量值）。  - EXPR（单个简单表达式，如t.a = 1）。  - IGNOREAGG（忽略AGG表达式）。   |
   
 表6表达式计算函数 
| 函数名                         | 函数原型                                                                                                                                                                                                                                                                                                | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 功能描述                                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|:---|:---|
| EXPR_COMPUTE                | ``` Node expr_compute(Node $args) ```                                                                                                                                                                                                                                                               | - 入参： $args： 类型：Node 描述：QueryTree中的表达式。   - 出参： $result： 类型：Node 描述：经过常量计算后的表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 常量表达式计算，例如将提取的表达式中可以计算为常量的表达式进行预处理，方便后续逻辑分析。 例如，将表达式中的1+1进行提前计算，得到常量值2；或者将1= 0进行提前计算，得到常量值false。                                                                                                                                                                                                                                          |
| BUILD_PROJECT               | ``` Node build_project(Node $args) ```                                                                                                                                                                                                                                                              | - 入参： $args： 类型：Node 描述：表的属性列，可以通过FIND_ATTRIBUTES等函数获取。   - 出参： $result： 类型：Node 描述：构造好的投影列集合。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 通过传入的表属性列，构造对应的投影列集合。                                                                                                                                                                                                                                                                                                                                                                  |
| BUILD_TABLE                 | ``` Node build_table(Node $args) ```                                                                                                                                                                                                                                                                | - 入参： $args： 类型：QUERY/Node 描述：QUERY结构体或FIND_TABLES的返回值。   - 出参： $result： 类型：Node 描述：新构造的表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 根据入参构造新的表。                                                                                                                                                                                                                                                                                                                                                                             |
| BUILD_BOOL_EXPR             | ``` Node build_bool_expr(DSLType $bool_type, Node $args1, DSLNode $args2) ```                                                                                                                                                                                                                       | - 入参： - $bool_type： 类型：DSLType 描述：可以选择AND或者OR，分别表示构造AND表达式或OR表达式。   - $args1： 类型：Node 描述：表达式的参数1，一般为一个链表，该函数使用该链表中的元素构造布尔表达式。   - $args2： 类型：DSLNode 描述：表达式的参数2，构造表达式使用的TEMPLATE，该函数支持的TEMPLATE节点为：NULLTEST。 当该参数为空时，表示直接使用$args1中的元素进行布尔表达式的构造，如： ``` /* 使用$v_list中的元素构造AND表达式 */ (build_bool_expr AND $v_list) ``` 当该参数不为空时，$args1中的元素先使用$args2的TEMPLATE构造表达式，再使用该表达式构造最终的布尔表达式，如： ``` /* 使用$v_list中的元素构造ISNULL表达式,再使用构造的表达式构造AND表达式 */ (build_bool_expr AND $v_list TEMPLATE {NULLTEST<ISNULL>{args: ELEMENT}} ) ```     - 出参： $result： 类型：Node 描述：构造的表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 构造指定类型的布尔表达式。                                                                                                                                                                                                                                                                                                                                                                          |
| BUILD_GROUP                 | ``` Node build_group(Node $args) ```                                                                                                                                                                                                                                                                | - 入参： $args： 类型：Node 描述：表的属性列，可以通过FIND_ATTRIBUTES等函数获取。   - 出参： $result： 类型：Node 描述：构造好的分组集合。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 根据输入表属性列构造分组信息。                                                                                                                                                                                                                                                                                                                                                                        |
| BUILD_FROMEXPR_BY_QUERY     | ``` Node build_fromexpr_by_query（Query $query, Node $table） ```                                                                                                                                                                                                                                     | - 入参： - $query： 类型：Query 描述：构建的表结构所属的Query结构，该结构包含表构造的信息。     - $table： 类型：Node 描述：需要创建的表，通常为原始表结构的一部分，通过匹配获取。     - 出参： $result： 类型：Node 描述：构造的目标表结构表达式。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 根据传入的表创建Query结构体的From表达式。                                                                                                                                                                                                                                                                                                                                                              |
| REMOVE_DISTINCT             | ``` bool remove_distinct（DSLExpr $query） ```                                                                                                                                                                                                                                                        | - 入参： $args： 类型：DSLExpr/Query 描述：可以选择THIS、ROOT或Query结构。 - THIS：表示当前层的QUERY。  - ROOT：表示根QUERY。  - QUERY：表示目标QUERY。    - 出参： $result： 类型：bool 描述：TRUE表示删除成功，反之FALSE表示失败。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 删除目标QUERY的DISTINCT部分。                                                                                                                                                                                                                                                                                                                                                                  |
| REMOVE_UNUSED_TABLE         | ``` bool remove_unused_table（DSLExpr $query） ```                                                                                                                                                                                                                                                    | - 入参： $args： 类型：DSLExpr/Query 描述：可以选择THIS、ROOT或Query结构。 - THIS：表示当前层的QUERY。  - ROOT：表示根QUERY。  - QUERY：表示目标QUERY。    - 出参： $result： 类型：bool 描述：TRUE表示删除成功，反之FALSE表示失败。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 删除目标QUERY的无用表，当对QUERY的FROM部分进行修改或重新创建时，需要执行该函数。                                                                                                                                                                                                                                                                                                                                        |
| FIND_UNIQUE_ATTR            | ``` List find_unique_attr(List $args, UniqueType $type) ```                                                                                                                                                                                                                                         | - 入参： - $args： 类型：List 描述：表属性列集合。     - $type： 类型：UniqueType 描述：唯一键类型，支持NotNullUnique（非空唯一索引）和 Unique（唯一索引）。       - 出参： $result： 类型：List 描述：返回满足条件的属性值，如果有多个（如：唯一索引）则仅返回匹配到的第一个约束。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 检查表基表是否包含唯一键。                                                                                                                                                                                                                                                                                                                                                                          |
| FIND_TABLES                 | ``` List find_tables(DSLNode $args, TableType $type, DSLType $include_join) ```                                                                                                                                                                                                                     | - 入参： - $args： 类型：DSLNode 描述：待提取的原始节点信息。   - $type： 类型：TableType 描述：要提取的表类型。 - ALL：所有表类型。  - BASEREL：基表。  - QUERY：子查询。  - JOIN：JOIN节点的表。  - FUNCTION：函数表。  - VALUES：VALUES表。  - CTE：CTE表。  - TBLRESULT：RESULT类型的表。  - XMLTABLE：XML表。    - $include_join： 类型：DSLType 描述：是否包含节点上层JOIN节点。 INCLUDEJOIN：包含节点上层JOIN节点。 NOTINCLUDEJOIN：不包含节点上层JOIN节点。 可以忽略，忽略时使用默认值NOTINCLUDEJOIN。       - 出参： $result： 类型：List 描述：返回表信息。    | 从节点中提取所有的Table表。                                                                                                                                                                                                                                                                                                                                                                       |
| FIND_ATTRIBUTES             | ``` List find_attributes(DSLNode $tablelist, DSLNode $args) List find_attributes(DSLNode $tablelist, DSLNode $args, DSLNode $table_query, DSLNode $find_attri_marks, DSLNode $do_dedup) ```                                                                                                         | - 入参： - $tablelist： 类型：DSLNode 描述：目标提取表的集合，可以通过find_tables函数进行获取。   - $args： 类型：DSLNode 描述：待提取的原始节点信息。   - $table_query 类型：DSLNode 描述：表集合所属的QUERY。 可选值：THIS（当前层QUERY）、ROOT（主查询QUERY）、变量（以$开头，在匹配阶段获取的变量）。   - $find_attri_marks 类型：DSLNode 描述：提取的列需要满足的属性限制。 默认值：ALL。 可选值：ALL（无属性要求）、NOTNULL（非空属性）、UNIQUE（UNIQUE属性）及其组合。   - $do_dedup 类型：DSLNode 描述：是否对提取的结果进行去重。 默认值：DEDUPLICATE。 可选值：DEDUPLICATE（去重）、NOTDEDUPLICATE（不去重）。       - 出参： $result： 类型：List 描述：返回表信息。                                                                                                                                                                                                                                                                                                                                                                                                                | 从节点中提取相关表属性。                                                                                                                                                                                                                                                                                                                                                                           |
| APPEND                      | ``` List append(List $arg1, List $arg2) ```                                                                                                                                                                                                                                                         | - 入参： - $arg1： 类型：List/Node 描述：列表类型节点。   - $arg2： 类型：List/Node 描述：列表或单个节点类型。       - 出参： 类型：List 描述：列表或单个节点类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 在一个List中追加另一个节点或List，或者将两个节点构造成一个List。                                                                                                                                                                                                                                                                                                                                                 |
| REPLACE_WITH                | ``` Node replace_with(DSLNode $arg1,  DSLNode $arg2, DSLNode $arg3) bool replace_with(DSLNode $arg1,  DSLNode $arg2, DSLNode $arg3, DSLNode $replace_node_option) bool replace_with(DSLNode $arg1,   DSLNode $arg2, DSLNode $arg3,   DSLNode $replace_node_option,  DSLNode $replace_node_mode) ``` | - 入参： - $arg1： 类型：DSLNode 描述：被替换节点的父节点。   - $arg2： 类型：DSLNode 描述：被替换的节点。   - $arg3： 类型：DSLNode 描述：替换的内容节点。   - $replace_node_option 类型：DSLNode 描述：新节点替换旧节点时的替换方式。 默认值：ASNEW。 可选值：DIRECT（浅拷贝）、ASNEW（深拷贝），该参数可以省略，省略时使用默认值ASNEW。   - $replace_node_mode 类型：DSLNode 描述：遍历被替换结构体时的行为，具体参见可选值中的描述。 默认值：ANY。 可选值：ANY（仅替换第一个满足条件的节点）、ALL（替换所有满足条件的节点），该参数可以省略，省略时使用默认值ANY。       - 出参： 类型：Node 描述：替换后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 用$arg3节点替换$arg1父节点中的$arg2节点。                                                                                                                                                                                                                                                                                                                                                           |
| REPLACE_WITH_REC            | ``` Node replace_with_rec (DSLNode $arg1,  DSLNode $arg2, DSLNode $arg3) bool replace_with_rec (DSLNode $arg1, DSLNode $arg2, DSLNode $arg3, DSLNode $replace_node_option) ```                                                                                                                      | - 入参： - $arg1： 类型：DSLNode 描述：被替换节点的父节点。   - $arg2： 类型：DSLNode 描述：被替换的节点。   - $arg3： 类型：DSLNode 描述：替换的内容节点。   - $replace_node_option 类型：DSLNode 描述：新节点替换旧节点时的替换方式。 默认值：ASNEW。 可选值：DIRECT（浅拷贝）、ASNEW（深拷贝）、UPDATE_COL_REF（更新Var结构体中的varno属性），该参数可以省略，省略时使用默认值ASNEW。       - 出参： 类型：Node 描述：替换后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 用$arg3节点替换父节点中递归查找到的$arg1节点。                                                                                                                                                                                                                                                                                                                                                           |
| REPLACE_TABLE               | ``` Node replace_table (QUERY $arg1, DSLNode $arg2, DSLNode $arg3, DSLNode $arg4 = DIRECT) ```                                                                                                                                                                                                      | - 入参： - $arg1： 类型：QUERY 描述：被替换节点的QUERY节点。   - $arg2： 类型：DSLNode 描述：被替换的表节点。   - $arg3： 类型：DSLNode 描述：替换的表节点。   - $arg4 ： 类型：DSLNode 描述：该参数为可选参数，表示替换表的方式。若未显式指定，默认值为DIRECT；若显式指定，取值仅可为ADD。 默认值：DIRECT，表示使用直接替换的方式。 可选值：ADD，表示新增节点替换。       - 出参： 类型：Node 描述：替换后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 使用$arg4标识的方式，用$arg3表节点替换$arg1QUERY节点中的$arg2表节点。                                                                                                                                                                                                                                                                                                                                        |
| REPLACE_TABLE_FOREACH       | ``` Node replace_table (QUERY $arg1, DSLNode $arg2, DSLNode $arg3) ```                                                                                                                                                                                                                              | - 入参： - $arg1： 类型：QUERY 描述：被替换节点的QUERY节点。   - $arg2： 类型：List 描述：被替换的表节点列表。   - $arg3： 类型：DSLNode 描述：替换的表节点。       - 出参： 类型：Node 描述：替换后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 用$arg3表节点替换QUERY节点中的$arg2集合中所有表节点。                                                                                                                                                                                                                                                                                                                                                     |
| FIND_EXPR_WITHOUT           | ``` List find_expr_without(Expr $args1, Expr $args2) ```                                                                                                                                                                                                                                            | - 入参： - $args1： 类型：Expr 描述：待处理的父表达式节点。   - $args2： 类型：Expr 描述：要排除的表达式节点。       - 出参： 类型：List 描述：排除目标表达式后剩余的表达式节点列表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 从$args1父表达式节点中查找不包含指定$args2表达式节点的部分。                                                                                                                                                                                                                                                                                                                                                   |
| FIND_EXPR_WITH              | ``` List find_expr_with(Expr $args, DSLType $flags, DSLType $any_all_type) ```                                                                                                                                                                                                                      | - 入参： - $args： 类型：Expr 描述：待处理的表达式节点。   - $flags： 类型：DSLType 描述：支持包含的类型，如：UPPERVAR表示包含上层查询块的Var。   - $any_all_type： 类型：DSLType 描述：提取满足条件的表达式，可以选择ALL或者ANY。 ALL ：提取所有满足条件的表达式。 ANY：提取第一个满足条件的表达式。     - 出参： 类型：List 描述：满足条件的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 从$args表达式中查找包含指定条件的部分。                                                                                                                                                                                                                                                                                                                                                                 |
| LIST_FIRST                  | ``` Node list_first(List $args) ```                                                                                                                                                                                                                                                                 | - 入参： $args： 类型：List 描述：待处理的列表。   - 出参： 类型：Node 描述：提取出的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 提取$args列表的第一个节点。                                                                                                                                                                                                                                                                                                                                                                       |
| LIST_LENGTH                 | ``` Integer list_length(List $args) ```                                                                                                                                                                                                                                                             | - 入参： $args： 类型：List 描述：待处理的列表。   - 出参： 类型：INTEGER 描述：列表的长度。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 获取列表的长度。                                                                                                                                                                                                                                                                                                                                                                               |
| PULL_RELA_ATTR              | ``` List pull_rela_attr(Expr $args, DSLType $flags) ```                                                                                                                                                                                                                                             | - 入参： - $args： 类型：Expr 描述：待处理的表达式节点。   - $flags： 类型：DSLType 描述：提取指定层的表达式，可以选择THIS、PARENT或PARENTS。 THIS：提取当前层的表达式。 PARENT：提取上一层的表达式。 PARENTS：提取上两层的表达式。     - 出参： 类型：List 描述：满足条件的表达式列表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 提取表达式中满足层数条件的表达式节点。                                                                                                                                                                                                                                                                                                                                                                    |
| PULL_EXPR_TO_QUERY          | ``` Node pull_expr_to_query(List $args, Query $query) ```                                                                                                                                                                                                                                           | - 入参： - $arg： 类型：Node 描述：待处理的表属性节点。   - $query： 类型：Query 描述：提取时的目标QUERY。     - 出参： 类型：Node 描述：提取后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 将$arg表属性节点提取到$query的节点中。                                                                                                                                                                                                                                                                                                                                                               |
| BUILD_EXPR_THROUGH_PULLUP   | ``` Node build_expr_through_pullup(Node $args, Query $query) ```                                                                                                                                                                                                                                    | - 入参： - $args 类型：Node 描述：待处理的表达式节点。   - $query 类型：Query 描述：提取时的目标QUERY，可以为build_table的结果，表示新创建Query。     - 出参： 类型：Node 描述：提取后的节点。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 通过相关的表达式和新创建的表，构建新的表达式。其中表达式中的表属性与新的表属性映射。                                                                                                                                                                                                                                                                                                                                             |
| REMOVE_QUERY_OPTION         | ``` bool remove_query_option(Query $query, DSLType $remove_query_options) ```                                                                                                                                                                                                                       | - 入参： - $query： 类型：Query 描述：代表需要移除指定部分的Query结构体。可选值：THIS、ROOT、Query结构。 - THIS：表示当前层的QUERY。  - ROOT：表示根QUERY。  - QUERY：表示目标QUERY。    - $remove_query_options 类型：DSLType 描述：代表Query结构体中需要被移除的部分。 可选值：DISTINCT、DISTINCT_ON、GROUP、SORT、LIMIT、OFFSET及其组合值。     - 出参： 类型：bool 描述：代表移除是否成功。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 移除Query结构体中的指定部分。                                                                                                                                                                                                                                                                                                                                                                      |
| BUILD_WHEN_EXPR             | ``` CaseWhen build_when_expr(CaseWhen $casewhen) ```                                                                                                                                                                                                                                                | - 入参： $casewhen： 类型：CaseWhen 描述：待生成的CaseWhen结构模板。   - 出参： 类型：CaseWhen 描述：生成的CaseWhen结构。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 生成CaseWhen结构体。                                                                                                                                                                                                                                                                                                                                                                         |
| BUILD_CASE_EXPR             | ``` CaseExpr build_case_expr(CaseExpr $caseexpr) ```                                                                                                                                                                                                                                                | - 入参： $caseexpr： 类型：CaseExpr 描述：待生成的CaseExpr结构模板。   - 出参： 类型：CaseExpr 描述：生成的CaseExpr结构。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 生成CaseExpr结构体。                                                                                                                                                                                                                                                                                                                                                                         |
| FIND_SAME_TABLES            | ``` List find_same_tables(List $args, DSLType $type) ```                                                                                                                                                                                                                                            | - 入参： - $args： 类型：List 描述：待处理的表的List。   - $type： 类型：DSLType 描述：待处理的表类型。 可选值：BASEREL（基表）。   - $table_check_options 类型：DSLType 描述：在函数处理过程中，对于特殊场景的处理方式。 可选值：空值（默认场景，按照默认方式处理）、SUPPORT_SPECIFIED_PARTITION（支持指定分区场景）。     - 出参： 类型：List 描述：相同表的Oid组成的链表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 查找相同的表，默认不支持指定分区场景。 说明： 指定分区场景示例： ``` SELECT * FROM t1 partition(p1), t2 partition(p2) WHERE t1.c1=t2.c1; ``` 该示例中，使用partition关键字指定了特定的分区。                                                                                                 |
| FIND_NODES_WITH_TEMPLATE    | ``` List find_nodes_with_template(Node $node, DSLNode $template, DSLType $rec_mode) ```                                                                                                                                                                                                             | - 入参： - $node： 类型：Node 描述：待被遍历处理的结构体。   - $template： 类型：DSLNode 描述：待匹配的目标模板。使用TEMPLATE关键字，对目标模板进行描述，格式为TEMPLATE {FUNC_TEMPLATE_NODE}。   - $rec_mode： 类型：DSLType 描述：遍历处理的模式。 可选值：CURRENTFIRST（前序遍历）、CHILDFIRST（后序遍历）、CURRENTONLY（仅匹配顶层节点），该参数可以省略，表示非递归模式，当该参数不为空时，入参$template仅支持为JOIN的模板。如： ``` /* 以后序遍历的方式，使用JOIN模板在$fr中进行匹配 */ find_nodes_with_template $fr template {JOIN<INNER>{  LEFT: $l : *                                                    RIGHT: $r : *  on: $o : *}} CHILDFIRST ```     - 出参： 类型：List 描述：与目标模板相匹配的结构体所组成的链表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 遍历结构体，查找与目标模板相匹配的结构。                                                                                                                                                                                                                                                                                                                                                                   |
| FOREACH_NODES_WITH_TEMPLATE | ``` bool foreach_nodes_with_template(DSLNode $arg1, DSLNode $arg2) ```                                                                                                                                                                                                                              | - 入参： - $arg1： 类型：DSLNode，具体为DSLExpr，其内部以链表形式存储find_nodes_with_template函数返回的结果。 描述：待处理的结构体的集合。   - $arg2： 类型：DSLNode 描述：对结构体的处理方式。     - 出参： 类型：bool 描述：函数执行是否成功。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 遍历链表中的每一个元素，并以指定的方式对每一个元素进行处理。                                                                                                                                                                                                                                                                                                                                                         |
| BUILD_SUBLINK               | ``` Sublink build_sublink(Node $sublink) Sublink build_sublink(Node $sublink, List $columns, List $operator) ```                                                                                                                                                                                    | - 入参： - $sublink： 类型：可以为Sublink或使用NOT类型的BoolExpr嵌套的Sublink。 描述：待构建的SubLink结构体模板。   - $columns: 类型：List 描述：在ANY、ALL、ROWCOMPARE类型的Sublink中，需要和Sublink对比的列。   - $operator： 类型：List 描述：需要在ANY、ALL、ROWCOMPARE类型的Sublink中执行的操作。 可选值：EQ、NE、GT、GE、LT、LE、PLUS、ANY。     - 出参： - 类型：Sublink  - 描述：构建的Sublink结构体。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 构建Sublink结构体。 - 对于ANY、ALL、ROWCOMPARE类型的SUBLINK，使用包含三个入参的函数。  - 对于其他类型的SUBLINK，使用包含一个入参的函数。   |
| DSLNODE_COPY                | ``` Node dslnode_copy(Node $node, DSLType $copy_node_option) ```                                                                                                                                                                                                                                    | - 入参： - $node： 类型：Node 描述：待复制的DSLNode结构体。   - $copy_node_option: 类型：DSLType 描述：复制的方式。 可选值：DIRECT（浅拷贝）、ASNEW（深拷贝），该参数可以省略，省略时使用默认值DIRECT。     - 出参： 类型：Node 描述：复制生成的DSLNode结构体。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 复制DSLNode结构体。                                                                                                                                                                                                                                                                                                                                                                          |
| FIND_EQUALCLASS_VARS        | ``` List find_equalclass_vars(BoolExpr $exprs, DSLNode $bool_expr_type, DSLNode $operator_type) ```                                                                                                                                                                                                 | - 入参： - $exprs： 类型：由OpExpr所组成的集合，当前支持AND类型的BoolExpr。 描述：生成等价类时所依据的表达式。   - $bool_expr_type: 类型：DSLNode 描述：在生成等价类时，支持的多个表达式之间的逻辑关系类型。 可选值：AND。   - $operator_type： 类型：DSLNode 描述：在生成等价类时，支持的OpExpr的类型。 可选值：EQ。     - 出参： 类型：二维List。其中每个子List代表一个等价类；子List中的元素为Var，这些Var之间存在等价类关系。 描述：等价类组成的链表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 根据表达式生成等价类。                                                                                                                                                                                                                                                                                                                                                                            |
| FIND_REDUNDANT_INFO         | ``` List find_redundant_info(List $equalclass_list) ```                                                                                                                                                                                                                                             | - 入参： $equalclass_list： 类型：二维List。其中每个子List代表一个等价类；子List中的元素为Var，这些Var之间存在等价类关系。 描述：生成冗余信息时所依据的等价类信息。该信息由find_equalclass_vars函数生成。   - 出参： 类型：List。其内部元素为RedundantInfo结构体，结构体包含必须表和冗余表等信息。 描述：根据等价类信息生成的冗余信息，用于在某些优化规则中消除冗余表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 根据等价类信息生成冗余信息，用于在某些优化规则中消除冗余表。                                                                                                                                                                                                                                                                                                                                                         |
| REMOVE_USELESS_CONDITION    | ``` BoolExpr remove_useless_condition(Query $query, BoolExpr $expr, DSLType $scenario_option, List $vars) ```                                                                                                                                                                                       | - 入参： - $query： 类型：Query 描述：代表需要移除指定部分的Query结构体。 可选值：THIS、ROOT、QUERY结构。 - THIS：表示当前层的QUERY。  - ROOT：表示根QUERY。  - QUERY：表示目标QUERY。    - $expr 类型：BoolExpr 描述：代表需要被处理的谓词条件的集合。   - $scenario_option 类型：DSL_TYPE 描述：代表需要处理的场景。 可选值：SAME_VAR_EQUAL_OPEXPR（同一个Var相等的场景，例如：var1=var1）。   - $vars 类型：List 描述：代表被处理的var的LIst。     - 出参： 类型：BoolExpr 描述：代表移除冗余的谓词条件后的BoolExpr。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 删除冗余的谓词条件。                                                                                                                                                                                                                                                                                                                                                                             |
   
