# 平台和客户端兼容性
很多平台都使用数据库系统，数据库系统的对外兼容性给平台提供了很大的便利。
 #### a_format_date_timestamp
**参数说明** **：**控制返回的日期时间。在A模式下，当事务开启时，函数current_date()、current_timestamp()、localtimestamp()返回当前SQL启动的时间戳。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：返回当前SQL启动的时间戳。
- off：返回事务开启的日期或日期及时间。
**默认值：**off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。在开启事务需要返回系统时间时可开启该参数。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在参数[a_format_version]值为10c和[a_format_dev_version]值为s7的情况下，支持开启该GUC参数的行为，具体请参见[a_format_dev_version]。
#### convert_string_to_digit
**参数说明** **：**设置隐式转换优先级，是否优先将字符串转为数字。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示优先将字符串转为数字。
- off：表示不优先将字符串转为数字。
**默认值** **：**on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**调整该参数会修改内部数据类型转换规则，导致不可预期的行为，请谨慎操作。
 #### character_set_connection
**参数说明：** 用于设置常量字符串的字符集。修改该参数会同步将[collation_connection]修改成该字符集的默认字符序。
- 在sql_compatibility='B'兼容模式下，设置b_format_version='5.7'、b_format_dev_version='s2'时生效。
- 在M-Compatibility模式下生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- sql_compatibility='B'兼容性模式下支持的字符集，请参见[COLLATE collation](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0279.html#ZH-CN_TOPIC_0000002793779209__zh-cn_topic_0283137629_zh-cn_topic_0237122117_zh-cn_topic_0059778169_l506a9e4b62be4f6880be407386b4032b)。
- 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：** 与当前[server_encoding](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1055.html#ZH-CN_TOPIC_0000002764460596__zh-cn_topic_0283137574_zh-cn_topic_0237124754_zh-cn_topic_0059778487_s6ea4fdcca287481ba5fff4d6defeaf79)保持一致。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置库级和会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**设置的字符集和当前环境不符时，可能导致多次转码，影响性能。
 #### collation_connection
**参数说明：** 用于设置常量字符串的字符序。修改该参数会同步将[character_set_connection]修改成该字符序的默认字符集。
- 在sql_compatibility='B'兼容模式下，设置b_format_version='5.7'、b_format_dev_version='s2'时生效。
- 在M-Compatibility模式下生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- sql_compatibility='B'兼容性模式下支持的字符集，请参见[COLLATE collation](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0279.html#ZH-CN_TOPIC_0000002793779209__zh-cn_topic_0283137629_zh-cn_topic_0237122117_zh-cn_topic_0059778169_l506a9e4b62be4f6880be407386b4032b)。
- 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：** 当前[server_encoding](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1055.html#ZH-CN_TOPIC_0000002764460596__zh-cn_topic_0283137574_zh-cn_topic_0237124754_zh-cn_topic_0059778487_s6ea4fdcca287481ba5fff4d6defeaf79)的默认字符序，若没有server_encoding的默认字符序，则为"default"。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置库级和会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**设置的字符序和当前环境不符时，可能导致多次转码，影响性能。
 #### character_set_client
**参数说明：** 该参数用于指定客户端字符集。同[client_encoding](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1038.html#ZH-CN_TOPIC_0000002793698821__zh-cn_topic_0283136798_zh-cn_topic_0237124733_zh-cn_topic_0059778109_sfd35b29b745f4d5b9544f07b9ef676a6)含义一致。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：**与客户端字符集一致。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**设置的字符集和当前环境不符时，可能会出现乱码。
#### character_set_database
**参数说明：**该参数用于指定DATABASE、Schema的字符集。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：**同当前database的字符集一致。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在M-Compatibility模式下生效。
#### collation_database
**参数说明：**该参数用于显示DATABASE、Schema的字符序。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 在M-Compatibility模式下取值范围为其支持的字符序，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：**当前database的字符集的默认字符序，若默认字符序不存在，则为"default"。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在M-Compatibility模式下生效。
#### character_set_server
**参数说明：**该参数用于指定创建DATABASE、Schema时的字符集。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：**同当前database的字符集一致。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置库级和会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在M-Compatibility模式下生效。
#### compatiable_o_function_version
**参数说明：**该参数通过指定版本号，改变对重载的系统函数的选择逻辑。该参数仅在A模式下生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- "auto"：表示选择范围为从507.1.0开始添加的重载的系统函数。
- "*具体的版本号*"：版本号为507.1.0及之后的版本，表示选择范围为从507.1.0开始到该版本之间的重载的系统函数。
**默认值：**"auto"
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**调整该参数会改变重载的系统函数的选择逻辑，可能导致选择到错误的重载的系统函数，请谨慎操作。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
假如选择的版本号为507.1.0.SPC1100，则需将该参数的值设置为"507.1.0.1100"；假如选择的版本号为507.1.0（没有SPC版本号），则需将该参数的值设置为"507.1.0.0"。
#### collation_server
**参数说明：**该参数用于指定创建DATABASE、Schema时的字符序。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 在M-Compatibility模式下取值范围为其支持的字符序，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
**默认值：**当前database的字符集的默认字符序，若默认字符序不存在，则为"default"。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置库级和会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在M-Compatibility模式下生效。
#### character_set_results
**参数说明：**用于设置返回结果的字符集。
- 在sql_compatibility = 'B'兼容模式下，设置b_format_version='5.7'、b_format_dev_version='s2'时生效。
- 在M-Compatibility模式下生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- sql_compatibility='B'兼容性模式下支持的字符集，请参见[COLLATE collation](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0279.html#ZH-CN_TOPIC_0000002793779209__zh-cn_topic_0283137629_zh-cn_topic_0237122117_zh-cn_topic_0059778169_l506a9e4b62be4f6880be407386b4032b)。
- 在M-Compatibility模式下取值范围为其支持的字符集，请参见[字符集与字符序](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0439.html)。
- 还可以设置成null或''，此时直接以数据库的字符集输出。
**默认值：** 与当前[client_encoding](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1038.html#ZH-CN_TOPIC_0000002793698821__zh-cn_topic_0283136798_zh-cn_topic_0237124733_zh-cn_topic_0059778109_sfd35b29b745f4d5b9544f07b9ef676a6)保持一致。
**设置方式：** 该参数属于USERSET类型参数，但不支持通过GUC工具设置，仅支持方式三设置会话级别，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**设置的字符集和当前环境不符时，可能会出现乱码。
#### enable_multiple_charset
**参数说明：**该参数用于控制在M-Compatibility模式数据库下，是否可以创建表、列、Schema指定字符集和当前数据库字符集不同。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：可以创建表、列、Schema指定字符集和当前数据库字符集不同。
- off：不可以创建表、列、Schema指定字符集和当前数据库字符集不同。
**默认值：**on
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据实际业务需求设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_show_view_original_definition
**参数说明：**该参数用于控制在A模式数据库下查询视图定义时，显示用户输入的原始SELECT语句。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：表示查询视图定义时，显示用户输入的原始SELECT语句。
- off：表示查询视图定义时，按照将QUERY TREE反解析方式显示SELECT语句。
**默认值：**off
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据实际业务需求设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在A模式下，该参数会影响\\d+、dba_views、all_views、user_views、information_schema.views、pg_views、pg_get_viewdef等查询视图信息的函数或视图的显示结果。
#### fixed_date
**参数说明：**该参数用于控制在A模式数据库下，设置参数后可固定sysdate的值。
**参数类型：**字符串
**参数单位：**无
**取值范围：**格式为timestamp所支持的所有格式，数值范围为datea所表示的时间范围（0001\~9999）。日期设置不支持负数，负数表示公元前时间，如需要设置可在时间后加上'BC'。
**默认值：**""
**设置方式：** 该参数属于SUSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据实际业务需求设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。该参数不允许在生产环境开启，仅用于调试。
#### mapping_date_to_datea
**参数说明**：该参数用于控制在A兼容模式下，是否用datea类型替换date类型。
**参数类型：**布尔型
**参数单位：**无
**取值范围**：
- on：用datea类型替换date类型。
- off：date类型的行为维持默认状态。
**默认值：**新安装数据库为on；若升级的基础版本不存在该GUC参数，默认为off；若升级的基础版本存在该GUC参数，保留原设置。
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。支持在数据库安装时指定，如未指定，默认值为on，表示用datea类型替换date类型。可通过以下方式用于安装时打开或关闭该参数：
```
gs_install --dn-guc="mapping_date_to_datea=off" --gsinit-parameter="-- mapping_date_to_datea off"
```
**设置不当的风险与影响：**在A兼容模式下，可能导致date类型的范围、精度、格式等与预期不符。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 该参数在升级观察期设置不生效。
- 该参数在安装数据库时指定，不建议在数据库启动后对参数进行修改。若在数据库运行过程中修改，系统视图、系统表以及修改参数之前与date数据类型相关数据将保持修改参数前的状态，不会发生变化。新建立的对象则会使用datea类型替换date类型。
- 升级场景下，升级提交后若修改该参数值，低版本上创建的数据将保持参数修改前的状态，不会发生变化。例如低版本该参数值设置为off，升级到高版本后设置该参数为on，低版本上创建的date类型数据仍为映射为timestamp，如需使用新的datea类型，请按照数据类型中的说明重新创建对象。
 
#### nls_date_format
**参数说明** **：**在A兼容模式下，用于DATEA类型和字符类型转换时的格式控制。
**参数类型：**字符串
**参数单位：**无
**取值范围** **：** nls_date_format支持的格式请参见[表2](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0010.html#ZH-CN_TOPIC_0000002764300402__table16439192504520)，且支持'-'、'/'、','、'.'、'%'、':'或用""包含的字符串作为分隔符。
**默认值** **：**"DD-MON-RR"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据实际业务需求设置，建议不要频繁变更。
**设置不当的风险与影响：**可能导致DATEA类型输入时格式校验失败，产生报错，或输入时间结果与预期不符。
#### nls_timestamp_format
**参数说明** **：**设置时间戳默认格式。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围** **：**字符串
**默认值** **：**"DD-Mon-YYYY HH:MI:SS.FF AM"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### nls_timestamp_tz_format
**参数说明** **：**在A兼容模式下，设置带时区时间戳默认格式。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围** **：**字符串
**默认值** **：**"DD-Mon-YYYY HH:MI:SS.FF AM"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
此参数在参数[a_format_version]值为10c和[a_format_dev_version]值为s1的情况下有效。
#### nls_nchar_characterset
**参数说明：**搭配nchr(cvalue int\|bigint)系统函数使用，设置国家字符集。该参数可在PDB级别设置。
**参数类型** **：**字符串
**参数单位** **：**无
**取值范围：**"AL16UTF16"、"UTF8"，不区分大小写。
**默认值：**"AL16UTF16"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式** **：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议** **：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 数据库不支持国家字符集，该参数只是为了兼容A数据库，获取用户想使用的国家字符集。
- 该GUC参数仅限于nchr(cvalue int\|bigint)函数的使用。
 
#### group_concat_max_len
**参数说明：**搭配函数group_concat()使用，限制其返回值长度，超长截断，并产生相应报错/告警。当sql_mode设置含有STRICT_TRANS_TABLES时，DML语句中会产生报错，其余场景中提示告警。该参数可在PDB级别设置。
**参数类型：**整型
**参数单位：**无
**取值范围：**0 \~ 9223372036854775807，目前实际生效的最大长度是1073741823，超出此长度后会有out of memory的报错。
**默认值：**1024。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**设置过小可能导致group_concat()返回的结果被截断。
#### lastval_supported
**参数说明：**控制是否可以使用lastval()函数。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示支持lastval()函数，同时nextval()函数不支持下推。
- off：表示不支持lastval()函数，同时nextval()函数可以下推。
**默认值：**off
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### max_function_args
**参数说明**：函数参数最大个数。
**参数类型：**整型
**参数单位：**个
**取值范围**：8192
**默认值**：8192
**设置方式：**该参数属于INTERNAL类型参数，为固定参数，用户无法修改此参数，只能查看。
**设置建议：**该参数不允许用户进行设置，只能查看。
**设置不当的风险与影响：**无
#### max_subpro_nested_layers
**参数说明**：嵌套子程序的最大嵌套深度。该参数可在PDB级别设置。
**参数类型：**整型
**参数单位：**无
**取值范围**：0 \~ 100
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
当设置为0时，不允许使用嵌套子程序。
**默认值**：3。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据最大嵌套情况设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### transform_null_equals
**参数说明：**是否控制表达式expr=NULL（或NULL=expr）当作expr IS NULL处理。正确的SQL标准兼容的expr=NULL总是返回NULL（未知）。Microsoft Access里的过滤表单生成的查询使用expr=NULL来测试空值。打开这个选项后，可以使用该接口来访问数据库。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示控制表达式expr=NULL（或NULL=expr）当作expr IS NULL处理，如果expr得出NULL值则返回真，否则返回假。
- off：表示不控制，即expr=NULL总是返回NULL（未知）。
**默认值：**off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
新用户经常在涉及NULL的表达式上语义混淆，故默认值设为off。
#### support_extended_features
**参数说明：**控制是否支持数据库的扩展特性。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示支持数据库的扩展特性。
- off：表示不支持数据库的扩展特性。
**默认值：**off
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### sql_compatibility
**参数说明：**控制数据库的SQL语法和语句行为同哪一个主流数据库兼容。
**参数类型：**枚举类型
**参数单位：**无
**取值范围：**
- A：表示同O数据库兼容。
- B：表示同MY数据库兼容。
- C：表示同TD数据库兼容。
- PG：表示同POSTGRES数据库兼容。
- M：表示M-Compatibility。
**默认值：**A
**设置方式：**该参数属于INTERNAL类型参数，为固定参数，用户无法修改此参数，只能查看。
**设置建议：**该参数不允许用户进行设置，只能查看。
**设置不当的风险与影响：**无
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 该参数只能在执行CREATE DATABASE命令（具体请参见[CREATE DATABASE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0247.html)）创建数据库的时候设置。
- 在数据库中，该参数只能是确定的一个值，要么始终设置为A，要么始终设置为B，请勿任意改动，否则会导致数据库行为不一致。
 
 #### b_format_behavior_compat_options
**参数说明：**数据库B模式兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表1 B模式兼容性配置项]，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开，例如：set b_format_behavior_compat_options="enable_set_variables,set_session_transaction";。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
当参数b_format_version不为""时，b_format_behavior_compat_options会被设置为"all"，而且不能被修改。
 表1B模式兼容性配置项 
| 兼容性配置项                    | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                |
|:---|:---|
| enable_set_variables     | set语法增强控制开关。 - 不设置此配置时，不支持set自定义变量、set \[global \| session\]语法。  - 设置此配置时，支持B兼容模式下使用上述语法，比如*set @v1 = 1；*。                                                                                  |
| set_session_transaction | set session transaction控制开关。 - 不设置此配置时，set session transaction等效于set local transaction。  - 设置此配置时，支持B兼容模式下使用上述语法，修改当前会话事务特性。                                                       |
| enable_modify_column     | ALTER TABLE MODIFY语义控制开关。 - 不设置此配置时，"ALTER TABLE table_name MODIFY column_name data_type;"只修改列的数据类型。  - 设置此配置时，"ALTER TABLE table_name MODIFY column_name data_type;"修改整个列定义。   |
| default_collation      | 默认字符序前向兼容开关。 - 若不设置此配置项，在未显式指定字符类型字段的字符集或字符序且表级字符序也为空时，字段为default字符序。  - 若设置此配置项，当表级字符序不为空时，字符类型字段的字符序继承表级字符序，当表级字符序为空时，字符类型字段的字符序设置为数据库编码对应的默认字符序。                                    |
| all                   | 打开所有语法控制开关。 all不能同时和其他配置项一起指定。表格中除all外所有配置项逗号隔开的含义和取值为all含义相同。                                                                                                                                                                                                                                                                                                                        |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**控制一些B兼容性特性是否可用，若要更改，请在理解参数含义后谨慎操作，避免因误操作产生意料之外的风险。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### m_format_behavior_compat_options
**参数说明：**数据库M-Compatibility模式的兼容性行为配置项。多租场景下，该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表2]，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开。
**默认值：**
- 新安装的数据库："disable_zero_chars_conversion,disable_illegal_function_syntax,cast_as_new_json,grant_database_nomapping,enable_load_data_remote_transmission,forbid_none_space_comment,enable_samename_funcs,enable_uca_collate,between_and_independent_compare,enable_bit_string_logic,compat_bool_cond,enable_param_charset_connection,fix_sort_pad_space"。
- 从历史版本升级上来的数据库，若历史版本不支持该GUC参数，升级后的默认值为""；若历史版本支持该GUC参数，升级后默认值保留原设置。
- 在PDB场景内，若未设置该参数，则继承来自全局的设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在参数m_format_dev_version值为s4的情况下，支持部分兼容性配置项的行为，具体请参见[m_format_dev_version]。
 表2M-Compatibility模式兼容性配置项 
| 兼容性配置项                                 | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|
| enable_escape_string                    | 转义符控制开关。 - 不设置此配置项时，转义符行为受GaussDB转义符相关的GUC参数[standard_conforming_strings](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1042.html#ZH-CN_TOPIC_0000002764460184__zh-cn_topic_0283136754_zh-cn_topic_0237124737_zh-cn_topic_0059778091_se4bd34e1d69b4139a8793e8a4cb5a785)、[escape_string_warning](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1042.html#ZH-CN_TOPIC_0000002764460184__zh-cn_topic_0283136754_zh-cn_topic_0237124737_zh-cn_topic_0059778091_s2506905b3bff4a1694bbfe0e27fab17a)和[backslash_quote](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1042.html#ZH-CN_TOPIC_0000002764460184__zh-cn_topic_0283136754_zh-cn_topic_0237124737_zh-cn_topic_0059778091_sdcdb8f0f54734b778d8ac509d5a2d08b)控制。  - 设置此配置项时，默认支持除'\\0'外的所有MySQL转义符，且gsql客户端中'\\b', '\\r'和'\\Z'回显行为会发生改变，与MySQL客户端保持一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| enable_conflict_funcs               | 冲突函数控制开关。 - 不设置此配置项时，ceil、format、instr、position、row_number、rank、dense_rank、regexp_instr、regexp_like、regexp_replace及regexp_substr函数保持GaussDB原生系统函数行为。  - 设置此配置项，且参数[m_format_dev_version]值为's2'或以上版本时，ceil、format、instr、position、row_number、rank及dense_rank函数为M-Compatibility模式数据库实现行为。使用regexp_instr、regexp_like、regexp_replace及regexp_substr函数时会报错，提示M-Compatibility兼容模式数据库不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| select_column_name                   | 列名回显控制开关。目前只有M兼容模式下支持，在B模式下是不支持的。需要设置m_format_behavior_compat_options ='select_column_name'，特性开关为用户级，缺省关闭。 - 不设置此配置项时： - SELECT 系统函数：回显为系统函数名。  - SELECT 表达式：回显为?column?。  - SELECT 布尔值：回显为bool。    - 设置此配置项时，列名回显为全部的函数或表达式输入。 - 仅支持集中式，使用商用客户端测试。  - 如果显示的列名字符串中含有转义字符，只有在设置了m_format_behavior_compat_options ='enable_escape_string';后才会显示转义后的字符，否则会显示转义字符本身。比如SELECT"abc\\tdef";M兼容在未开启上述设置时显示为abc\\tdef。 ``` m_db=# set m_format_behavior_compat_options='select_column_name,enable_escape_string'; SET m_db=# SELECT "abc\tdef"; abc     def ------------- abc     def (1 row) m_db=# set m_format_behavior_compat_options='select_column_name'; SET m_db=# SELECT "abc\tdef"; abc\tdef ---------- abc\tdef (1 row) ```   - 列名超过63个字节时，会截断后面部分。  - 表达式最后的部分为注释时，则不会显示最后的注释以及与注释相连的空格。 ``` m_db=# SELECT 123        /* 456 */; 123 ----- 123 (1 row) ```   - 表达式为布尔值时，无论输入大小写，回显为TRUE或FALSE。 ``` m_db=# SELECT true; TRUE ------ t (1 row) ```   - 表达式为null时，无论输入大小写，回显为NULL。 ``` m_db=# SELECT null; NULL ------ (1 row) ```   - 表达式包含-时，会将全部的输入作为列名输出。 ``` m_db=# SELECT (+-+1); (+-+1) -------- -1 (1 row) m_db=# SELECT -true; -true ------- -1 (1 row) m_db=# SELECT -null; -null ------- (1 row) ```                                                                                                                                                                 |
| enable_precision_decimal             | 支持数据类型精度。 - 不设置此配置项时： - CREATE TABLE SELECT语句只支持SELECT表的列，不支持表达式、函数、常量，以及union场景（因为涉及结果类型推导）。    - 设置此配置项时： - CREATE TABLE SELECT语句不受限制上面描述的场景限制。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| disable_illegal_function_syntax        | 用于控制系统函数中不合法的语法功能。 - 不设置此项时，以下场景的系统函数语法功能正常可用。 - 无入参的系统函数支持参数为(\*)的调用。  - 普通系统函数支持结合WITHIN GROUP使用。  - 普通系统函数入参支持结合ORDER BY使用。  - 普通系统函数支持结合OVER子句使用。  - 聚合函数支持结合WITHIN GROUP使用。      - 设置此项时，上述场景将被禁用。   ``` -- 未设置disable_illegal_function_syntax m_db=# set m_format_behavior_compat_options=''; SET m_db=# SELECT pi(*); pi ------------------- 3.141592653589793 (1 row) -- 设置了disable_illegal_function_syntax m_db=# set m_format_behavior_compat_options='disable_illegal_function_syntax'; SET m_db=# SELECT pi(*); ERROR:  pi(*) specified, but pi is not an aggregate function LINE 1: SELECT pi(*); ^ CONTEXT:  referenced column: pi ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| cast_as_new_json                     | 支持JSON类型执行::JSON转换时转换为M-Compatibility模式数据库的JSON类型。 - 不设置此配置项时：执行::JSON、CREATE TABLE \<tablename\> AS \<包含JSON类型的SELECT查询\>; 等涉及使用::JSON方式进行JSON类型转换的场景，实际转换为非M-Compatibility模式数据库（即GaussDB原有）的JSON类型。  - 设置此配置项时：执行::JSON、CREATE TABLE \<tablename\> AS \<包含JSON类型的SELECT查询\>; 等涉及使用::JSON方式进行JSON类型转换的场景，实际转换为M-Compatibility模式数据库JSON类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| grant_database_nomapping             | M-Compatibility模式数据库下GRANT \| REVOKE ON DATABASE语法行为配置项。 - 不设置此配置项时：GRANT \| REVOKE ON DATABASE语法映射成GRANT \| REVOKE ON SCHEMA行为，赋予或回收指定的用户或角色对模式层级对象的访问权限。  - 设置此配置项时：GRANT \| REVOKE ON DATABASE语法保留非M-Compatibility模式数据库（即GaussDB原有）默认兼容性库中GRANT \| REVOKE ON DATABASE语法的行为，赋予或回收指定的用户或角色对数据库层级对象的访问权限。 ``` -- 创建用户和数据库。 \c postgres DROP USER IF EXISTS testUser cascade; DROP DATABASE IF EXISTS m_db; CREATE USER testUser WITH PASSWORD '********'; CREATE DATABASE m_db DBCOMPATIBILITY='M'; \c m_db -- 未打开选项，映射为GRANT SCHEMA，提示无法找到Schema。 m_db=# SET m_format_behavior_compat_options=''; SET m_db=# GRANT CREATE ON DATABASE m_db TO testUser; ERROR:  schema "m_db" does not exist m_db=# SET SESSION AUTHORIZATION testUser PASSWORD '********'; SET m_db=> CREATE SCHEMA s1; ERROR:  Permission denied for database m_db. DETAIL:  N/A. m_db=> \c - -- 打开选项，成功授予CREATE SCHEMA权限。 m_db=# SET m_format_behavior_compat_options='grant_database_nomapping'; SET m_db=# GRANT CREATE ON DATABASE m_db TO testUser; GRANT m_db=# SET SESSION AUTHORIZATION testUser PASSWORD '********'; SET m_db=> CREATE SCHEMA s1; CREATE SCHEMA m_db=> \c - -- 清理。 \c postgres DROP USER IF EXISTS testUser cascade; DROP DATABASE IF EXISTS m_db; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| disable_zero_chars_conversion          | 驱动PBE接口通过文本模式传参时，"\\0"字符转换为空格的行为配置项。 - 不设置此配置项时：服务端会将参数中的"\\0"字符转换为空格。  - 设置此配置项时：服务端禁止将参数中的"\\0"字符转换为空格。   ``` // JDBC示例： // 创建数据表。 PreparedStatement ps = conn.prepareStatement("drop table if exists t_varchar;"); ps.executeUpdate(); ps = conn.prepareStatement("create table t_varchar(a varchar(50), id int);"); ps.executeUpdate(); // setString文本方式传参。 String val = "\u0001\u0000\u0001"; String sql = "insert into t_varchar values(?, ?)"); ps = conn.prepareStatement(sql); ps.setString(1, val); ps.setInt(2, 2); ps.executeUpdate(); ps.close(); // 查询插入的数据。 Statement stm = conn.createStatement(); ResultSet rs = stm.executeQuery("select hex(a) as res from t_varchar;"); while (rs.next()) { // 打开disable_zero_chars_conversion选项时，结果为01 00 01 // 关闭disable_zero_chars_conversion选项时，结果为01 20 01 System.out.println(rs.getString("res")); } rs.close(); stm.close(); ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| enable_update_tuple_count              | 执行UPDATE操作时，控制数量统计是否去重。 - 不设置此配置项时：统计不去重。 ``` -- 未设置enable_update_tuple_count m_db=# SET m_format_behavior_compat_options=''; SET m_db=# CREATE TABLE t1 (a int); CREATE TABLE m_db=# INSERT INTO t1 VALUES (1); INSERT 0 1 m_db=# UPDATE t1 SET a = 1; UPDATE 1 ```   - 设置此配置项时：统计去重。 ``` -- 设置enable_update_tuple_count m_db=# SET m_format_behavior_compat_options='enable_update_tuple_count'; SET m_db=# CREATE TABLE t1 (a int); CREATE TABLE m_db=# INSERT INTO t1 VALUES (1); INSERT 0 1 m_db=# UPDATE t1 SET a = 1; UPDATE 0 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| enable_load_data_remote_transmission | LOAD DATA支持从客户端导入数据。 不设置此项时：LOAD DATA指定LOCAL参数后将从服务端所在环境导入文件。 设置此配置项时：LOAD DATA指定LOCAL参数后将从客户端所在环境导入数据。 说明： 当指定m_format_behavior_compat_options中包含值enable_load_data_remote_transmission时，LOAD DATA命令后不支持和其他SQL语句一起执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| forbid_none_space_comment           | 支持"-- "单行注释语法。 - 不设置此配置项时："--"后的内容（"--"后无论是否添加空格，"--"后的全部内容）全部被视为单行注释内容。  - 设置此配置项时：仅"-- "后的内容（"--"后添加空格，空格之后的内容）将被视为单行注释内容。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| enable_samename_funcs               | 同名函数控制开关。 - 不设置此配置项时：current_user函数（不指定参数方式调用，即直接调用"SELECT current_user;"）、stddev函数以及round函数的函数行为保持GaussDB原生系统函数行为。  - 设置此配置项时：current_user函数（不指定参数方式调用，即直接调用"SELECT current_user;"）、stddev函数以及round函数的函数行为按照M-Compatibility模式数据库实现行为实现。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| enable_convert_charset                 | 字符集间转码规则控制开关，具体实现行为请参见[字符集间转码规则](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0446.html)章节。 - 不设置此配置项时：使用GaussDB原生字符集转码规则（即GaussDB的非M-Compatibility模式数据库的字符集转码规则），可以通过pg_conversion系统表查看是否支持两字符集间字符转码。  - 设置此配置项时：使用GaussDB的M-Compatibility模式数据库的字符集转码规则，支持M-Compatibility模式数据库下任意两个支持的字符集间转码。转码过程中，若源字符的编码不在目标字符集的支持范围内，系统将自动用 '?' 代替该字符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| enable_uca_collate                  | 用于控制utf8_unicode_ci、utf8mb4_unicode_ci字符序行为。 - 设置此项时，使用UCA 4.0(Unicode Collation Algorithm) 规则比较，对于一些不可比较字符（如0字符、非法字符）比较时会跳过。  - 不设置此项时，和utf8mb4_general_ci规则一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| between_and_independent_compare       | 用于控制A BETWEEN B AND C语句的隐式转换逻辑（其中A、B和C表示为需要比较的变量或常量）。 - 设置此项时，A与B、A与C分别进行独立比较，并选择比较类型。 ``` -- 开启between_and_independent_compare选项时，A与B、A与C分别进行独立比较，并选择比较类型。 m_db=# SET m_format_behavior_compat_options ='between_and_independent_compare'; SET m_db=# CREATE TABLE t_datetime_mix (pk INT AUTO_INCREMENT PRIMARY KEY, c1 DATETIME); NOTICE:  CREATE TABLE will create implicit sequence "t_datetime_mix_pk_seq" for serial column "t_datetime_mix.pk" NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t_datetime_mix_pkey" for table "t_datetime_mix" CREATE TABLE m_db=# EXPLAIN SELECT * FROM t_datetime_mix t1 WHERE t1.c1 BETWEEN "20230101AA" AND 20230101101112; WARNING:  Incorrect datetime value: '20230101AA' QUERY PLAN ---------------------------------------------------------------------------------------------------------- Seq Scan on t_datetime_mix t1  (cost=0.00..44.04 rows=216 width=12) Filter: (((c1 <= '2023-01-01 10:11:12'::datetime)) AND ( (cast_to_cstring(c1) >= '20230101AA'::text))) (2 rows) m_db=# DROP TABLE IF EXISTS t_datetime_mix; DROP TABLE ```   - 不设置此项时，A、B、C会尝试转换为同一类型进行比较。 ``` -- 未开启between_and_independent_compare选项时，A、B、C会尝试转换为同一类型进行比较。 m_db=# SET m_format_behavior_compat_options =''; SET m_db=# CREATE TABLE t_datetime_mix (pk INT AUTO_INCREMENT PRIMARY KEY, c1 DATETIME); NOTICE:  CREATE TABLE will create implicit sequence "t_datetime_mix_pk_seq" for serial column "t_datetime_mix.pk" NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "t_datetime_mix_pkey" for table "t_datetime_mix" CREATE TABLE m_db=# EXPLAIN SELECT * FROM t_datetime_mix t1 WHERE t1.c1 BETWEEN "20230101AA" AND 20230101101112; WARNING:  The double value '20230101AA' is incorrect. QUERY PLAN -------------------------------------------------------------------------------------------------------------- Seq Scan on t_datetime_mix t1  (cost=0.00..48.90 rows=10 width=12) Filter: (((cast_to_float8(c1) >= 20230101::double)) AND ( (cast_to_float8(c1) <= 20230101101112::double))) (2 rows) m_db=# DROP TABLE IF EXISTS t_datetime_mix; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                           |
| disable_int_cmp_num_index              | 用于控制整型与定点型常量比较时，是否转换成整型与整型进行比较。 - 不设置此项时，整型与定点型常量比较时，转换成整型与整型比较。（假设存在整型列索引，整型列与定点型常量比较时，可以执行索引）。 ``` -- 未开启disable_int_cmp_num_index选项时，整型与定点型常量比较时，转换成整型与整型比较，可以执行索引。 m_db=# SET m_format_behavior_compat_options=''; SET m_db=# DROP TABLE IF EXISTS t1; DROP TABLE m_db=# CREATE TABLE t1(a BIGINT, b INT); CREATE TABLE m_db=# CREATE INDEX idx_t1_a ON t1(a); CREATE INDEX m_db=# INSERT INTO t1 VALUES(generate_series(0, 500), generate_series(0, 500)); INSERT 0 501 m_db=# EXPLAIN SELECT * FROM t1 WHERE a < 5.1; QUERY PLAN -------------------------------------------------------------------------- Bitmap Heap Scan on t1  (cost=13.27..31.37 rows=648 width=12) Recheck Cond: (a <= 5::bigint) ->  Bitmap Index Scan on idx_t1_a  (cost=0.00..13.11 rows=648 width=0) Index Cond: (a <= 5::bigint) (4 rows) m_db=# DROP TABLE IF EXISTS t1; DROP TABLE ```     - 设置此项时，整型与定点型常量比较时，转换成定点型与定点型比较。（假设存在整型列索引，整型列与定点型常量比较时，会由于整型转换成定点型，导致无法执行整型列索引。） ``` -- 开启disable_int_cmp_num_index选项时，转换成定点型与定点型比较，无法执行索引。 m_db=# SET m_format_behavior_compat_options='disable_int_cmp_num_index'; SET m_db=# DROP TABLE IF EXISTS t1; DROP TABLE m_db=# CREATE TABLE t1(a BIGINT, b INT); CREATE TABLE m_db=# CREATE INDEX idx_t1_a ON t1(a); CREATE INDEX m_db=# INSERT INTO t1 VALUES(generate_series(0, 500), generate_series(0, 500)); INSERT 0 501 m_db=# EXPLAIN SELECT * FROM t1 WHERE a < 5.1; QUERY PLAN ------------------------------------------------------ Seq Scan on t1  (cost=0.00..39.17 rows=648 width=12) Filter: (cast_to_numeric(a) < 5.1) (2 rows) m_db=# DROP TABLE IF EXISTS t1; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| enable_bit_string_logic              | 默认开启，用于设置字符类型表字段与二进制常量或PBE二进制绑定参数的比较逻辑。 说明： 通过JDBC驱动的setByte、setBlob等接口进行参数绑定时，由于当前JDBC未指定参数为二进制类型，因此无论是否设置此选项，都会按照字符类型比较。 - 设置此项时，若为字符类型表字段与二进制常量或PBE二进制绑定参数的场景比较，将会按照字符类型的比较逻辑进行处理。 ``` m_db=# CREATE TABLE t_char(c1 CHAR(20)); CREATE TABLE m_db=# INSERT INTO t_char VALUES('ABC'); INSERT 0 1 m_db=# SET m_format_behavior_compat_options='enable_bit_string_logic'; SET m_db=# EXPLAIN (COSTS OFF) SELECT * FROM t_char WHERE c1=x'616263'; QUERY PLAN ------------------------------ Seq Scan on t_char Filter: (c1 = 'abc'::text) (2 rows) m_db=# DROP TABLE IF EXISTS t_char; DROP TABLE ```   - 不设置此项时，若为字符类型表字段与二进制常量或PBE二进制绑定参数的场景进行比较，将会按照二进制的比较逻辑进行处理。 ``` m_db=# CREATE TABLE t_char(c1 CHAR(20)); CREATE TABLE m_db=# INSERT INTO t_char VALUES('ABC'); INSERT 0 1 m_db=# SET m_format_behavior_compat_options=''; SET m_db=# EXPLAIN (COSTS OFF) SELECT * FROM t_char WHERE c1=x'616263'; QUERY PLAN -------------------------------------------------- Seq Scan on t_char Filter: (cast_to_binary(c1) = 'abc'::`binary`) (2 rows) m_db=# DROP TABLE IF EXISTS t_char; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| create_table_float_precision          | 默认关闭，用于决定FLOAT(P)、FLOAT、DOUBLE类型列的精度。 - 未设置此项时，FLOAT(P)、FLOAT、DOUBLE列精度为255。 例如：FLOAT(P)与VARCHAR(1)列进行UNION操作得到的列精度为VARCHAR(255)。 ``` m_db=# CREATE TABLE t_char(c1 VARCHAR(1)); CREATE TABLE m_db=# CREATE TABLE t_float_1(c1 FLOAT(7)); CREATE TABLE m_db=# CREATE TABLE t_float_2(c1 FLOAT(25)); CREATE TABLE m_db=# SET m_format_behavior_compat_options='enable_precision_decimal'; SET m_db=# CREATE TABLE t_union_1 as SELECT c1 from t_char union select c1 from t_float_1; INSERT 0 0 m_db=# desc t_union_1; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c1    | varchar(255) | YES  |     |         | (1 row) m_db=# CREATE TABLE t_union_2 as SELECT c1 from t_char union select c1 from t_float_2; INSERT 0 0 m_db=# desc t_union_2; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c1    | varchar(255) | YES  |     |         | (1 row) m_db=# DROP TABLE IF EXISTS t_char; DROP TABLE m_db=# DROP TABLE IF EXISTS t_float_1; DROP TABLE m_db=# DROP TABLE IF EXISTS t_float_2; DROP TABLE ```   - 设置此项时，FLOAT(P)列的精度根据P值确定，当P值\>24时，精度为22，否则精度为12。FLOAT列精度为12，DOUBLE列精度为22。 例如：FLOAT(7)与VARCHAR(1)列进行UNION操作得到的列精度为VARCHAR(12)；FLOAT(25)与VARCHAR(1)列进行UNION操作得到的列精度为VARCHAR(22)。 ``` m_db=# SET m_format_behavior_compat_options='enable_precision_decimal,create_table_float_precision'; SET m_db=# CREATE TABLE t_char(c1 VARCHAR(1)); CREATE TABLE m_db=# CREATE TABLE t_float_1(c1 FLOAT(7)); CREATE TABLE m_db=# CREATE TABLE t_float_2(c1 FLOAT(25)); CREATE TABLE m_db=# CREATE TABLE t_union_1 as SELECT c1 from t_char union select c1 from t_float_1; INSERT 0 0 m_db=# desc t_union_1; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c1    | varchar(12) | YES  |     |         | (1 row) m_db=# CREATE TABLE t_union_2 as SELECT c1 from t_char union select c1 from t_float_2; INSERT 0 0 m_db=# desc t_union_2; Field |     Type     | Null | Key | Default | Extra -------+--------------+------+-----+---------+------- c1    | varchar(22) | YES  |     |         | (1 row) m_db=# DROP TABLE IF EXISTS t_char; DROP TABLE m_db=# DROP TABLE IF EXISTS t_float_1; DROP TABLE m_db=# DROP TABLE IF EXISTS t_float_2; DROP TABLE ```    |
| compat_bool_cond                    | 默认开启，用于控制非BOOL类型表达式转换为BOOL类型时的转换逻辑。 - 未设置此项时，VARCHAR、DECIMAL、TIME等非BOOL类型的表达式转换为BOOL类型时，先转为整数（小数时四舍五入），非0则为TRUE，否则为FALSE。 例如：未设置此项时，0.4转整数为0，条件结果为FALSE。 ``` m_db=# SET m_format_behavior_compat_options=''; SET m_db=# SELECT 1 WHERE 0.4; ?column? ---------- (0 rows) ```   - 设置此项时，VARCHAR、DECIMAL、TIME等非BOOL类型的表达式转换为BOOL类型时，先转为浮点数，非0则为TRUE，否则为FALSE。 例如：设置此项时，0.4转浮点数结果为0.4，非0所以条件结果为TRUE。 ``` m_db=# SET m_format_behavior_compat_options='compat_bool_cond'; SET m_db=# SELECT 1 WHERE 0.4; ?column? ---------- 1 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| enable_param_charset_connection       | 默认开启，用于控制字符类型表字段与PBE绑定字符类型参数的比较逻辑。 - 未设置此项时，当参数character_set_connection（常量字符串字符集）与server_encoding（服务端字符集）不一致时，使用setString绑定多字节字符（比如中文字符）参数，执行报错无效编码。  - 设置此项时，当参数character_set_connection（常量字符串字符集）与server_encoding（服务端字符集）不一致时，使用setString绑定多字节字符（比如中文字符）参数，内部编码转换成功，能正常查询结果。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| fix_sort_pad_space                    | 默认开启，用于控制在支持PAD SPACE的字符序下排序结果的逻辑，以及其他内部涉及到排序的语法的结果。 - 未设置此项时，在支持PAD SPACE的字符序下，''和' '不会被GROUP BY归为同一组。 ``` m_db=# SET m_format_behavior_compat_options=''; SET m_db=# DROP TABLE IF EXISTS tbl_group_by; DROP TABLE m_db=# CREATE TABLE tbl_group_by (c24 tinytext,c29 time(3),c38 bit) charset utf8mb4 collate utf8mb4_general_ci; CREATE TABLE m_db=# INSERT INTO tbl_group_by (c24, c29, c38) m_db-# VALUES m_db-# ('', '838:59:59.000', 1), m_db-# (' ', '23:59:59.999', 0), m_db-# ('', '23:59:59.999', 0); INSERT 0 3 m_db=# SELECT hex(c24),c29, c38, count(*) as total FROM tbl_group_by GROUP BY c24, c29, c38 ORDER BY 1,2,3; hex |      c29      | c38 | total -----+---------------+-----+------- | 23:59:59.999  | 0   |     1 | 838:59:59.000 | 1   |     1 20  | 23:59:59.999  | 0   |     1 (3 rows) ```   - 设置此项时，在支持PAD SPACE的字符序下，''和' '会被GROUP BY归为同一组。 ``` m_db=# SET m_format_behavior_compat_options='fix_sort_pad_space'; SET m_db=# DROP TABLE IF EXISTS tbl_group_by; DROP TABLE m_db=# CREATE TABLE tbl_group_by (c24 tinytext,c29 time(3),c38 bit) charset utf8mb4 collate utf8mb4_general_ci; CREATE TABLE m_db=# INSERT INTO tbl_group_by (c24, c29, c38) m_db-# VALUES m_db-# ('', '838:59:59.000', 1), m_db-# (' ', '23:59:59.999', 0), m_db-# ('', '23:59:59.999', 0); INSERT 0 3 m_db=# SELECT hex(c24),c29, c38, count(*) as total FROM tbl_group_by GROUP BY c24, c29, c38 ORDER BY 1,2,3; hex |      c29      | c38 | total -----+---------------+-----+------- | 838:59:59.000 | 1   |     1 20  | 23:59:59.999  | 0   |     2 (2 rows) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在未开启精度传递参数（m_format_behavior_compat_options不开启enable_precision_decimal选项）情况下创建的索引在开启精度传递参数后会发生失效，如果打开精度传递时需要重新创建索引。
#### system_function_version
**参数说明：**数据库系统函数行为配置项。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表3]，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开，例如："SET system_function_version='get_hash_value_fix,pbe_trunc_fix,empty_array_fix';"。
**默认值：**
- 安装时：get_hash_value_fix,pbe_trunc_fix,empty_array_fix,regex_like_m_fix,parse_phrase_fix
- 升级时：""
 表3兼容性配置项 
| 兼容性配置项               | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
|:---|:---|
| get_hash_value_fix | dbe_utility.get_hash_value前向兼容开关。 - 若不设置此配置项，对于用户输入的字符串会忽略后4个字节，导致小于4个字节的字符串的hash值一致。  - 若设置此配置项，修复该问题，保证hash值的正确性。   ``` gaussdb=# SET system_function_version = ''; gaussdb=# SELECT dbe_utility.get_hash_value(1, 1024, 1024); get_hash_value ---------------- 1444 (1 row) gaussdb=# SELECT dbe_utility.get_hash_value(2, 1024, 1024); get_hash_value ---------------- 1444 (1 row) gaussdb=# SET system_function_version = 'get_hash_value_fix'; gaussdb=# SELECT dbe_utility.get_hash_value(1, 1024, 1024); get_hash_value ---------------- 1785 (1 row) gaussdb=# SELECT dbe_utility.get_hash_value(2, 1024, 1024); get_hash_value ---------------- 1538 (1 row) ``` |
| pbe_trunc_fix      | pbe场景时lpad/rpad/chr/round/trunc/add_months/instrb函数前向兼容开关。 - 若不设置此配置项，在pbe场景时上述函数的入参小数点会按照四舍五入转换整型。  - 若设置此配置项，在pbe场景时上述函数的入参小数点会按照整数截断转换整型，保证与A结果一致。   ``` gaussdb=# SET a_format_version='10c'; gaussdb=# SET a_format_dev_version='s1'; gaussdb=# PREPARE pround1 AS SELECT round(123.456,$1); gaussdb=# EXECUTE pround1('2.6'); round --------- 123.456 (1 row) gaussdb=# SET system_function_version = 'pbe_trunc_fix'; gaussdb=# PREPARE pround1 AS SELECT round(123.456,$1); gaussdb=# EXECUTE pround1('2.6'); round --------- 123.46 (1 row) ``` 说明： 该参数仅在数据库兼容性为A时有效。                                              |
| empty_array_fix   | 控制空数组的前向兼容开关。 - 若不设置此配置项，类似array_positions函数等操作构建的空数组与'{}'::int\[\]构建的空数组不相等。  - 若设置此配置项，类似array_positions函数等操作构建的空数组与'{}'::int\[\]构建的空数组相等。   ``` gaussdb=# SET system_function_version = 'empty_array_fix'; SET gaussdb=# SELECT array_eq(array_positions(array[1, 1, 1], 3), '{}'::int[]); array_eq ---------- t (1 row) gaussdb=# SET system_function_version = ''; SET gaussdb=# SELECT array_eq(array_positions(array[1, 1, 1], 3), '{}'::int[]); array_eq ---------- f (1 row) ```                                                                                                                                                                       |
| regex_like_m_fix    | 控制regex_like_m函数行为的前向兼容开关。（regexp_like函数的实现中调用了regex_like_m，所以也受影响。） - 若不设置此配置项，在多行匹配且正则规则中有'\|'时，匹配结果错误。  - 若设置此配置项，在多行匹配且正则规则中有'\|'时，匹配结果正确。   ``` gaussdb=# SET system_function_version = 'regex_like_m_fix'; SET gaussdb=# SELECT 'abc' FROM dual WHERE regex_like_m('111 2 222','^1+$|^2+$'); ?column? ---------- abc (1 row) gaussdb=# SET system_function_version = ''; SET gaussdb=# SELECT 'abc' FROM dual WHERE regex_like_m('111 2 222','^1+$|^2+$'); ?column? ---------- (0 row) ``` 说明： 该配置项仅对从匹配结果错误的版本升级上来的数据库生效。对于新安装的数据库，无论是否设置该配置项，行为均与设置该配置项时的行为一致。                                                |
| parse_phrase_fix   | tsquery中控制是否解析词组操作符的开关。 - 若不设置此配置项，to_tsquery等涉及解析tsquery的操作不会解析词组操作符。  - 若设置此配置项，to_tsquery等涉及解析tsquery的操作将解析词组操作符。   ``` gaussdb=# SET system_function_version = 'parse_phrase_fix'; SET gaussdb=# SELECT to_tsquery('hello <-> world'); to_tsquery --------------------- 'hello' <-> 'world' (1 row) gaussdb=# SET system_function_version = ''; SET gaussdb=# SELECT to_tsquery('hello <-> world'); ERROR:  syntax error in tsquery: "hello <-> world" CONTEXT:  referenced column: to_tsquery ```                                                                                                                                                                   |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。升级时默认为空，若客户需要打开设置时，建议修改GUC配置文件，保证数据库重启时不会丢失设置项。
**设置建议：**控制一些系统函数兼容性特性是否可用，若要更改，请在理解参数含义后谨慎操作。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### behavior_compat_options
**参数说明：**数据库兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表4]，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开，例如：set behavior_compat_options='end_month_calculate,display_leading_zero';。
**默认值：**
- 新安装的数据库："forbid_package_function_with_prefix,enable_bpcharlikebpchar_compare,enable_crosstype_integer_operator,forbid_skip_tableof_empty_str_elem,forbid_update_multi_same_tables,enable_ora_joinop_in_updatestmt"。
- 从历史版本升级上来的数据库，若历史版本不支持该GUC参数，升级后的默认值为""；若历史版本支持该GUC参数，升级后默认值保留原设置。
- 在PDB场景内，若未设置该参数，则继承来自全局的设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
在参数a_format_version值为10c和a_format_dev_version值为s7的情况下，支持部分兼容性配置项的行为，具体请参见[a_format_dev_version]和[a_format_version]。
 表4兼容性配置项 
| **兼容性配置项**                            | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|
| display_leading_zero            | 浮点数显示配置项。控制数值类型中char、character、nchar、varchar、character varying、varchar2、nvarchar2、text、clob等所有字符串类型和float4、float8、numeric等任意精度类型的小数点前0的显示，length计算数字长度时是否包含小数点前的0。 - 不设置此配置项时，对于-1\~0和0\~1之间的小数，不显示小数点前的0。比如： ``` gaussdb=# select 0.1231243 as a, 0.1231243::numeric as b,0.1231243::integer(10,3) as c, length(0.1242343) as d; a     |    b     |  c   | d ----------+----------+------+--- .1231243 | .1231243 | .123 | 8 (1 row) ```   - 设置此配置项时，对于-1\~0和0\~1之间的小数，显示小数点前的0。比如： ``` gaussdb=# select 0.1231243 as a, 0.1231243::numeric as b,0.1231243::integer(10,3) as c, length(0.1242343) as d; a     |     b     |   c   | d -----------+-----------+-------+--- 0.1231243 | 0.1231243 | 0.123 | 9 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| end_month_calculate              | add_months函数计算逻辑配置项。 此参数在M-Compatibility模式数据库下不生效。 假定函数add_months的两个参数分别为param1和param2，param1的月份和param2的和为月份result。 - 不设置此配置项时，如果param1的日期（Day字段）为月末，并且param1的日期（Day字段）比result月份的月末日期小，计算结果中的日期字段（Day字段）和param1的日期字段保持一致。比如： ``` gaussdb=# select add_months('2018-02-28',3) from sys_dummy; add_months --------------------- 2018-05-28 00:00:00 (1 row) ```     - 设置此配置项时，如果param1的日期（Day字段）为月末，并且param1的日期（Day字段）比result月份的月末日期比小，计算结果中的日期字段（Day字段）和result的月末日期保持一致。比如： ``` gaussdb=# select add_months('2018-02-28',3) from sys_dummy; add_months --------------------- 2018-05-31 00:00:00 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| compat_analyze_sample              | analyze采样行为配置项。 设置此配置项时，会优化analyze的采样行为，主要体现在analyze时全局采样会更精确的控制在三万条左右，更好地控制analyze时DBnode端的内存消耗，保证analyze性能的稳定性。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| bind_schema_tablespace            | 绑定模式与同名表空间配置项。 如果存在与模式名schema_name相同的表空间名，那么如果设置search_path为schema_name， default_tablespace也会同步切换到schema_name。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| bind_procedure_searchpath         | 未指定模式名的存储过程中的数据库对象的搜索路径配置项。 在存储过程中如果不显式指定模式名，会优先在存储过程所属的模式下搜索。 如果找不到，则有两种情况： - 若不设置此参数，报错退出。  - 若设置此参数，按照search_path中指定的顺序继续搜索。如果还是找不到，报错退出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| a_hash_bpchar                                                                    | 开启此参数后，hashbpchar函数会保留字符串末尾空格来计算哈希值。在当前版本中，该参数支持设置，但不生效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| correct_to_number                   | 控制to_number()结果兼容性的配置项。 - 若不设置此配置项，则to_number()函数结果默认与A数据库保持一致。 ``` gaussdb=# select '' AS to_number_14, to_number('34,50','999,99'); ERROR:  invalid data. CONTEXT:  referenced column: to_number ```     - 若设置此配置项，则to_number()函数结果与pg11保持一致。 ``` gaussdb=# select '' AS to_number_14, to_number('34,50','999,99'); to_number_14 | to_number --------------+----------- |      3450 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| unbind_divide_bound                                                             | 控制对整数除法的结果进行范围校验。 此参数在M-Compatibility模式数据库下不生效。 - 若不设置此配置项，则会对除法结果做范围校验，例如，INT_MIN/(-1)会因为输出结果大于INT_MAX而报越界错误。 ``` gaussdb=# select (-2147483648)::int4 / (-1)::int4; ERROR:  integer out of range ```     - 若设置此配置项，则不需要对除法结果做范围校验，例如，INT_MIN/(-1)可以得到输出结果为INT_MAX+1。 ``` gaussdb=# select (-2147483648)::int4 / (-1)::int4; ?column? ------------ 2147483648 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| convert_string_digit_to_numeric | 控制当表中以字符串形式表示的numeric常量和数字类型做比较时，是否都统一转换为numeric类型再进行比较。 此参数在M-Compatibility模式数据库下不生效。 - 若不设置此配置项，不会将以字符串形式表示的numeric常量转换为numeric类型。  - 若设置此配置项，会将以字符串形式表示的numeric常量转换为numeric类型。   ``` gaussdb=# create table test1 (c1 int, c2 varchar); gaussdb=# insert into test1 values (2, '1.1'); gaussdb=# set behavior_compat_options=''; gaussdb=# select * from test1 where c2 > 1; ERROR:  invalid input syntax for type bigint: "1.1" gaussdb=# set behavior_compat_options='convert_string_digit_to_numeric'; gaussdb=# select * from test1 where c2 > 1; c1 | c2 ----+----- 2 | 1.1 (1 row) gaussdb=# drop table test1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| return_null_string               | 控制函数lpad()和rpad()结果为空字符串''的显示配置项。 此参数在M-Compatibility模式数据库下不生效。 - 不设置此配置项时，空字符串显示为NULL。 ``` gaussdb=# select length(lpad('123',0,'*')) from sys_dummy; length -------- (1 row) ```     - 设置此配置项时，空字符串显示为''。 ``` gaussdb=# select length(lpad('123',0,'*')) from sys_dummy; length -------- 0 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| compat_concat_variadic           | 控制函数concat()和concat_ws()对variadic类型结果兼容性的配置项。由于B数据库无variadic类型，所以该选项对B数据库无影响。 - 若不设置此配置项，当concat函数参数为variadic类型时，默认A数据库和C数据库兼容模式下结果相同，且与A数据库保持一致。 ``` gaussdb=# select concat(variadic NULL::int[]) is null; ?column? ---------- t (1 row) ```     - 若设置此配置项，当concat函数参数为variadic类型时，保留A数据库和C数据库兼容模式下不同的结果形式。 ``` --A数据库下： gaussdb=# select concat(variadic NULL::int[]) is null; ?column? ---------- t (1 row) --C数据库下： gaussdb=# select concat(variadic NULL::int[]) is null; ?column? ---------- f (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| merge_update_multi                 | 控制在使用MERGE INTO ... WHEN MATCHED THEN UPDATE（具体请参见[MERGE INTO](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0373.html)）和INSERT ... ON DUPLICATE KEY UPDATE（具体请参见[INSERT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0365.html)）时，当目标表中一条目标数据与多条源数据冲突时UPDATE行为。 - 若设置此配置项，当存在上述场景时，该冲突行将会多次执行UPDATE。  - 若不设置此配置项（默认），则报错，即MERGE或INSERT操作失败。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| plstmt_implicit_savepoint                                                        | 控制存储过程中更新语句的执行是否拥有独立的子事务。 若设置此配置项，存储过程中每条更新语句前开启隐式保存点，EXCEPTION块中默认回退到最近的保存点，从而保证只回退失败语句的修改。该选项是为了兼容Oracle数据库的EXCEPTION行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| hide_tailing_zero                                                             | numeric显示配置项。 - 若设置此配置项，所有输出numeric的场景均隐藏小数点后的末尾0，包括指定format精度情况。  - 若不设置此配置项，numeric按照指定精度显示。   例如： ``` gaussdb=# set behavior_compat_options='hide_tailing_zero'; gaussdb=# select cast(123.123 as numeric(15,10)) as a, to_char(cast(123.123 as numeric(15,10)), '999D999999'); a    | to_char ---------+---------- 123.123 |  123.123 (1 row) gaussdb=# set behavior_compat_options=''; gaussdb=# select cast(123.123 as numeric(15,10)) as a, to_char(cast(123.123 as numeric(15,10)), '999D999999'); a        |   to_char ----------------+------------- 123.1230000000 |  123.123000 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| truncate_numeric_tail_zero                                                    | numeric显示配置项。 - 若设置此配置项，除to_char(numeric, format)这种显式设置精度的情况外，所有输出numeric的场景均会隐藏小数点后的末尾0。  - 若不设置此配置项，numeric按照默认精度显示。   例如： ``` gaussdb=# set behavior_compat_options='truncate_numeric_tail_zero'; gaussdb=# select cast(123.123 as numeric(15,10)) as a, to_char(cast(123.123 as numeric(15,10)), '999D999999'); a    |   to_char ---------+------------- 123.123 |  123.123000 (1 row) gaussdb=# set behavior_compat_options=''; gaussdb=# select cast(123.123 as numeric(15,10)) as a, to_char(cast(123.123 as numeric(15,10)), '999D999999'); a        |   to_char ----------------+------------- 123.1230000000 |  123.123000 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| char_coerce_compat                                                              | 控制char(n)类型向其它变长字符串类型转换时的行为。该参数仅在sql_compatibility参数的值为A时生效，并且开启该参数后无论是隐式转换、显式转换还是通过调用text(bpchar)函数转换类型都不再省略尾部空格。 - 若设置此配置项，转换时不再省略尾部的空格，并且如果char(n)类型的长度超过其它变长字符串类型，将会报错。  - 若不设置此配置项，char(n)类型转换其它变长字符串类型时，会省略尾部的空格。   ``` gaussdb=# set behavior_compat_options=''; gaussdb=# create table tab_1(col1 varchar(3)); gaussdb=# create table tab_2(col2 char(3)); gaussdb=# insert into tab_2 values('   '); gaussdb=# insert into tab_1 select col2 from tab_2; gaussdb=# select * from tab_1 where col1 is null; col1 ------ (1 row) gaussdb=# select * from tab_1 where col1='   '; col1 ------ (0 rows) gaussdb=# delete from tab_1; gaussdb=# set behavior_compat_options = 'char_coerce_compat'; gaussdb=# insert into tab_1 select col2 from tab_2; gaussdb=# select * from tab_1 where col1 is null; col1 ------ (0 rows) gaussdb=# select * from tab_1 where col1='   '; col1 ------ (1 row) gaussdb=# drop table tab_1; gaussdb=# drop table tab_2; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| rownum_type_compat                                                                | 控制ROWNUM的类型，ROWNUM默认类型为BIGINT，设置此参数后，ROWNUM类型变更为NUMERIC类型。 ``` gaussdb=# set behavior_compat_options=''; gaussdb=# create table tb_test(c1 int,c2 varchar2,c3 varchar2); gaussdb=# insert into tb_test values(1,'a','b'); gaussdb=# create or replace view v_test as select rownum from tb_test; gaussdb=# \d+ v_test View "public.v_test" Column |  Type  | Modifiers | Storage | Description --------+--------+-----------+---------+------------- rownum | bigint |           | plain   | View definition: SELECT ROWNUM AS "rownum" FROM tb_test; gaussdb=# set behavior_compat_options = 'rownum_type_compat'; gaussdb=# create or replace view v_test1 as select rownum from tb_test; gaussdb=# \d+ v_test1 View "public.v_test1" Column |  Type   | Modifiers | Storage | Description --------+---------+-----------+---------+------------- rownum | numeric |           | main    | View definition: SELECT ROWNUM AS "rownum" FROM tb_test; gaussdb=# drop view v_test; gaussdb=# drop view v_test1; gaussdb=# drop table tb_test; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| aformat_null_test                                                                 | 控制rowtype类型判空逻辑。 此参数在M-Compatibility模式数据库下不生效。 设置此项时，对于rowtype is not null的判断逻辑为当一行数据有一列不为空的时候返回true；不设置此项时，对于rowtype is not null的判断逻辑为当一行数据所有列不为空的时候返回true。该参数不影响rowtype is null的判断。 ``` gaussdb=# set behavior_compat_options='aformat_null_test'; gaussdb=# select r, r is null as isnull, r is not null as isnotnull from (values (1,row(1,2)), (1,row(null,null)), (1,null), (null,row(1,2)), (null,row(null,null)), (null,null) ) r(a,b); r      | isnull | isnotnull -------------+--------+----------- (1,"(1,2)") | f      | t (1,"(,)")   | f      | t (1,)        | f      | t (,"(1,2)")  | f      | t (,"(,)")    | f      | t (,)         | t      | f (6 rows) gaussdb=# set behavior_compat_options=''; gaussdb=# select r, r is null as isnull, r is not null as isnotnull from (values (1,row(1,2)), (1,row(null,null)), (1,null), (null,row(1,2)), (null,row(null,null)), (null,null) ) r(a,b); r      | isnull | isnotnull -------------+--------+----------- (1,"(1,2)") | f      | t (1,"(,)")   | f      | t (1,)        | f      | f (,"(1,2)")  | f      | f (,"(,)")    | f      | f (,)         | t      | f (6 rows) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| aformat_regexp_match                                                             | 控制正则表达式函数的匹配行为。 设置此项，且sql_compatibility参数的值为A或B或在M-Compatibility兼容数据库时，正则表达式的flags参数支持的选项含义： 1. 默认不能匹配'\\n'字符。  2. flags中包含n选项时，'.'能够匹配'\\n'字符。  3. regexp_replace(source, pattern replacement)函数替换所有匹配的子串。  4. regexp_replace(source, pattern, replacement, flags)函数在flags值为null时，返回值为null。  5. 当sql_compatibility参数值为A，regexp_replace(source, pattern, replacement, flags)函数flags值为''时，返回值为null。   否则，正则表达式的flags参数支持的选项含义： 1. 默认能匹配'\\n'字符。  2. flags中的n选项表示按照多行模式匹配。  3. regexp_replace(source, pattern replacement)函数仅替换第一个匹配到的子串。  4. regexp_replace(source, pattern, replacement, flags)函数在flags值为null时，返回值为替换后的字符串。  5. 当sql_compatibility参数值为A，regexp_replace(source, pattern, replacement, flags)函数flags值为''时，返回值为替换后的字符串。   须知： 不建议在执行业务期间变更该参数的状态。该参数的状态变更可能会使得相同入参的regexp_replace函数的返回结果发生变化，如果regexp_replace函数在表达式索引中被引用，该参数的状态变更可能会导致数据异常。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| disable_rewrite_nesttable                                                      | 开启此参数后，针对pg_type表中tableof类型相关字段的重写会被禁用。即读取pg_type表时，会显示tableof类型实际存储的值。如果未开启此参数，查询pg_type系统表时，会对查询进行改写，此时针对pg_type的Hint将不会生效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| disable_emptystr2null                                                           | A兼容模式绑参场景中，开启此参数后，关闭默认将字符类型传参的值从空串转换为null功能。包括text、clob、blob、raw、bytea、varchar、nvarchar2、bpchar、char、name、byteawithoutorderwithqualcol、byteawithoutordercol类型。该参数为逃生参数，非必要用户不要自行设置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| compat_cursor                                                                    | 控制隐式游标状态及错误码变量兼容行为。设置此项，且兼容A，隐式游标状态（SQL%FOUND、SQL%NOTFOUND、SQL%ISOPEN、SQL%ROWCOUNT）及错误码变量（SQLCODE、SQLSTATE）由原先的仅在当前执行的函数有效，拓展到包括本函数调用的子函数有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| allow_procedure_compile_check                                                  | 控制存储过程中select语句和open cursor语句的编译检查。设置此项时，在存储过程中执行select语句、open cursor for语句、cursor%rowtype语句、for rec in语句时，若查询的表不存在，则无法创建存储过程，不支持trigger函数的编译检查，若查询的表存在，则成功创建存储过程。 注意：创建密态函数时，需要将allow_procedure_compile_check关闭。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| skip_insert_gs_source                                                             | 开启此参数后，创建PL/SQL对象时不再插入dbe_pldeveloper.gs_source表中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| select_into_return_null                                                          | 开启此参数后，存储过程语句SELECT*select_expressions* INTO \[STRICT\] *target* FROM ... 允许在不指定STRICT并且查询结果为空时给变量赋NULL值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| plsql_security_definer                                                            | 开启此参数后，创建存储过程时默认为定义者权限。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| proc_outparam_override                                                          | 控制存储过程出参的重载行为。 - 打开该参数后，对于存储过程只有OUT出参部分不同的情况，也可以正常创建和调用。存储过程在编译期间也会进行语法检查。目前只有gsql与jdbc连接数据库时可以使用该参数，对于其他工具打开该参数连接数据库时无法正常调用带有OUT的存储过程。  - 支持带有OUT出参的函数返回RECORD类型，且OUT出参正常赋值。  - 打开该参数后，高级包DBE_SQL.SQL_BIND_ARRAY不支持绑定参数。  - behavior_compat_options='proc_outparam_override'重载参数仅在A兼容模式可用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| proc_implicit_for_loop_variable                                                  | 控制存储过程中FOR_LOOP查询语句行为设置此项时，在FOR rec IN query LOOP语句中，若rec已经定义，不会复用已经定义的rec变量，而是重新建立一个新的变量。否则，会复用已经定义的rec变量，不会建立新的变量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| proc_uncheck_default_param                                                      | 函数调用时不检查默认参数省略情况配置项。 - 若不设置此配置项，调用带有默认参数的函数时，入参从左往右排入函数，如果有非默认参数的入参缺失则会报错。比如： ``` gaussdb=# create or replace function test(f1 int, f2 int default 20, f3 int, f4 int default 40, f5 int default 50) return int gaussdb-# as gaussdb$# begin gaussdb$# raise info 'f1:%',f1; gaussdb$# raise info 'f2:%',f2; gaussdb$# raise info 'f3:%',f3; gaussdb$# raise info 'f4:%',f4; gaussdb$# raise info 'f5:%',f5; gaussdb$# return 1; gaussdb$# end; gaussdb$# / CREATE FUNCTION gaussdb=# select test(1,2); ERROR:  function test(integer, integer) does not exist LINE 1: select test(1,2); ^ HINT:  No function matches the given name and argument types. You might need to add explicit type casts. CONTEXT:  referenced column: test gaussdb=# drop function test; ```   - 若设置此配置项，调用带有默认参数的函数时，入参从左往右排入函数，允许缺省默认参数的入参，如果有非默认参数的入参缺失，则会用错位的默认值填充该参数。比如： ``` gaussdb=# create or replace function test(f1 int, f2 int default 20, f3 int, f4 int default 40, f5 int default 50) return int gaussdb-# as gaussdb$# begin gaussdb$# raise info 'f1:%',f1; gaussdb$# raise info 'f2:%',f2; gaussdb$# raise info 'f3:%',f3; gaussdb$# raise info 'f4:%',f4; gaussdb$# raise info 'f5:%',f5; gaussdb$# return 1; gaussdb$# end; gaussdb$# / CREATE FUNCTION gaussdb=# select test(1,2); INFO:  f1:1 CONTEXT:  referenced column: test INFO:  f2:2 CONTEXT:  referenced column: test INFO:  f3:20 CONTEXT:  referenced column: test INFO:  f4:40 CONTEXT:  referenced column: test INFO:  f5:50 CONTEXT:  referenced column: test test ------ 1 (1 row) gaussdb=# drop function test; ``` 如上，f3被错误的默认值填充。 说明： 该场景下，非默认参数会被错位的默认值填充。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| dynamic_sql_compat                                                            | 开启此参数后： - 动态语句不会将模板SQL中的同名模板参数视为同一个变量，而是按照顺序依次匹配using子句中的变量值。  - 动态语句执行语句时调用存储过程的场景，会对存储过程中参数的IN/OUT属性和using子句中的IN/OUT属性进行检查。  - 应用场景：Execute immediate、open cursor for、return query、for var in execute sql绑定参数场景。   说明： 动态语句执行匿名块语句时调用存储过程的场景，只针对IN参数进行矫正，如果需要对OUT参数进行检查需要设置proc_outparam_override选项。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| dynamic_sql_check                                                                 | 开启此参数后，动态语句模板SQL中的不同模板参数个数与using子句中的变量个数不同时，将会在动态语句执行期间报错。 - 应用场景：Execute immediate、open cursor for、return query、for var in execute sql绑定参数场景。   说明： - 不推荐同时使用dynamic_sql_check选项和dynamic_sql_compat选项，开启dynamic_sql_compat选项后dynamic_sql_check选项将不再生效。  - 动态语句执行匿名块语句时调用存储过程的场景，只针对IN参数进行检查，如果需要对OUT参数进行检查需要设置proc_outparam_override选项。  - 动态语句执行匿名块语句时调用存储过程的场景，开启参数后不会对存储过程中参数的IN/OUT属性和using子句中的IN/OUT属性进行检查。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| enable_funcname_with_argsname                                                      | 开启参数后，使用select调用函数时投影别名显示完整函数。 - 若不设置此配置项，使用select调用函数时投影别名仅显示函数名。比如： ``` gaussdb=# select power(2,3); power ------- 8 (1 row) gaussdb=# select count(*) from db_ind_columns; count ------- 611 (1 row) gaussdb=# select count(index_name) from db_ind_columns; count ------- 611 (1 row) gaussdb=# select left('abcde', 2); left ------ ab (1 row) gaussdb=# select pg_client_encoding(); pg_client_encoding -------------------- UTF8 (1 row) ```   - 若设置此配置项，使用select调用函数时投影别名显示完整函数。比如： ``` gaussdb=# set behavior_compat_options = 'enable_funcname_with_argsname'; SET gaussdb=# select power(2,3); power(2,3) ------------ 8 (1 row) gaussdb=# select count(*) from db_ind_columns; count(*) ---------- 611 (1 row) gaussdb=# select count(index_name) from db_ind_columns; count(index_name) ------------------- 611 (1 row) gaussdb=# SELECT left('abcde', 2); left('abcde',2) ----------------- ab (1 row) gaussdb=# SELECT pg_client_encoding(); pg_client_encoding() ---------------------- UTF8 (1 row) ```   - 目前仅支持func_name(args_list)、func_name()、func_name(\*)三种形式投影别名显示完整函数，且参数args类型仅支持字符型常量、数值型常量、列名、函数。列名支持带有表名，但是func_name(\*)不支持\*前面带有表名。函数名支持带有schema、包名。不支持参数为表达式、仅支持参数带有DISTINCT关键字，不支持带有其他关键字时显示完整函数。  - 函数入参为以下场景时，投影别名不支持显示完整函数。 ``` gaussdb=# SET behavior_compat_options = 'enable_funcname_with_argsname'; SET -- 函数入参存在null值或者A兼容性下的空字符串。 gaussdb=# SELECT length(null); length -------- (1 row) gaussdb=# SHOW sql_compatibility; sql_compatibility ------------------- A (1 row) gaussdb=# SELECT length(''); length -------- (1 row) -- 函数入参为带双冒号的类型强制转换。 gaussdb=# SELECT length('abc'::text); length -------- 3 (1 row) -- 函数入参为指定类型转换。 gaussdb=# SELECT length(text'abc'); length -------- 3 (1 row) -- 函数入参为pbe占位符。 gaussdb=# PREPARE p1 AS SELECT length($1); PREPARE gaussdb=# EXECUTE p1('abc'); length -------- 3 (1 row) gaussdb=# DEALLOCATE p1; DEALLOCATE -- 函数入参为数组构造器。 gaussdb=# SELECT array_ndims(ARRAY[1, 2, 3]); array_ndims ------------- 1 (1 row) ```   - 函数带不同子句时，投影别名的差异如下： - 函数入参带有其他子句（如ORDER BY子句）时，投影别名仅支持显示函数名。  - 函数后接OVER、WITHIN子句时，投影别名支持显示函数名和入参，不支持显示OVER、WITHIN子句。  - 函数后接KEEP子句时，投影别名支持显示函数名，不支持显示入参和KEEP子句。 ``` gaussdb=# SET behavior_compat_options = 'enable_funcname_with_argsname'; SET gaussdb=# DROP TABLE IF EXISTS tbl; gaussdb=# CREATE TABLE tbl (id int, lower_col text, col1 int, col2 numeric); gaussdb=# INSERT INTO tbl VALUES (1, 'hello', 42, 3.14); -- 入参带ORDER BY子句 gaussdb=# SELECT string_agg(lower_col, '1' ORDER BY id) FROM tbl; string_agg ------------ hello (1 row) -- OVER子句 gaussdb=# SELECT min(col1) OVER(PARTITION BY id ORDER BY col2) FROM tbl; min(col1) ----------- 42 (1 row) -- WITHIN子句 gaussdb=# SELECT listagg(lower_col, ',') WITHIN GROUP(ORDER BY id) FROM tbl; listagg(lower_col,',') ------------------------ hello,world,test (1 row) -- KEEP子句 gaussdb=# SELECT min(col1) KEEP (DENSE_RANK FIRST ORDER BY col2) FROM tbl; min ----- 42 (1 row) gaussdb=# DROP TABLE IF EXISTS tbl; ```     - 在M-Compatibility模式数据库中，若同时设置此参数和m_format_behavior_compat_options = 'select_column_name'时，select_column_name优先生效。  - 部分函数既支持语法函数调用形式，又支持系统函数调用形式，不同调用方式会导致投影别名显示差异，函数列表参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0039.html#ZH-CN_TOPIC_0000002793779059__table1922613477459)。 - 仅使用函数名称调用时，投影别名不显示完整函数。  - 使用pg_catalog前缀或者双引号包裹调用函数时，投影别名显示完整函数。    - 投影列包含纯语法函数时，不支持完整投影别名显示，函数列表参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0039.html#ZH-CN_TOPIC_0000002793779059__table1922613477459)。纯语法函数的投影列名不一定显示函数名本身，而是显示该函数在语法解析阶段推导出的输出标识。 - 当最外层函数为纯语法函数时，投影列名仅显示该函数的名称。  - 若外层函数支持投影别名显示，但其参数中嵌套了纯语法函数，则仅显示外层函数名，而不显示纯语法函数名。    - 一些安全加解密函数、脱敏函数，投影别名显示完整函数可能存在安全问题，在这里就还是仅显示函数名。包括函数：gs_encrypt_aes128、gs_decrypt_aes128、gs_encrypt、gs_decrypt、gs_encrypt_bytea、gs_decrypt_bytea、aes_encrypt、aes_decrypt、pg_create_physical_replication_slot_extern、creditcardmasking、basicemailmasking、fullemailmasking、alldigitsmasking、shufflemasking、randommasking、regexpmasking、gs_digest、password、desencrypt、desdecrypt、des3encrypt、des3decrypt。  - 不支持=\>传参方式调用函数时投影别名显示完整函数，不支持投影别名显示""，如：select "power"(2,3)。  - 为了让投影别名显示完整函数，本功能不受去除末尾0等参数影响。  - 投影别名超过63个字节时，会截断后面部分。  - 参数args为数值型常量时，不支持投影别名显示前导0。 ``` gaussdb=# SET behavior_compat_options = 'enable_funcname_with_argsname'; SET gaussdb=# SELECT abs(0010); abs(10) --------- 10 (1 row) ```   - 在如下特殊场景中，投影别名有所差异： - 场景一：部分函数既是语法函数又是系统函数，函数列表参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0039.html#ZH-CN_TOPIC_0000002793779059__table1922613477459)，在支持不带括号调用的场景下，使用pg_catalog前缀调用时，不会显示pg_catalog前缀。  - 场景二：xmltype在带pg_catalog前缀或者双引号包裹调用时，会被当作系统函数调用，投影别名支持显示完整函数；仅使用xmltype调用时，会被当作语法函数调用，投影别名不支持显示完整函数。   ``` gaussdb=# SET behavior_compat_options = 'enable_funcname_with_argsname'; SET -- 场景一（当前用户为omm）： gaussdb=# SELECT pg_catalog.current_user; current_user -------------- omm (1 row) -- 场景二： gaussdb=# SELECT pg_catalog.xmltype('<a>1</a>'); pg_catalog.xmltype('<a>1</a>') -------------------------------- <a>1</a> (1 row) gaussdb=# SELECT "xmltype"('<a>1</a>'); xmltype('<a>1</a>') --------------------- <a>1</a> (1 row) gaussdb=# SELECT xmltype('<a>1</a>'); xmltype ---------- <a>1</a> (1 row) ```    |
| proc_outparam_transfer_length                                                  | 开启此参数后，存储过程和函数支持out出参长度传递，会在内层存储过程或者函数中报错。例如： ``` gaussdb=# SET behavior_compat_options='proc_outparam_override,proc_outparam_transfer_length'; SET gaussdb=# CREATE OR REPLACE PROCEDURE out_param_test1(m in int, v inout varchar2,v1 inout varchar2) is gaussdb$# begin gaussdb$#     v := 'aaaddd'; gaussdb$# v1 := 'aaaddd'; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CREATE OR REPLACE PROCEDURE call_out_param_test1 is gaussdb$#     v varchar2(5) := 'aabbb'; gaussdb$# v1 varchar2(6) := 'aabb'; gaussdb$# begin gaussdb$#     out_param_test1(5,v,v1); gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CALL call_out_param_test1(); ERROR:  value too long for type character varying(5) CONTEXT:  PL/SQL function out_param_test1(integer,character varying,character varying) line 3 at assignment PL/SQL function call_out_param_test1() line 4 at SQL statement gaussdb=# DROP PROCEDURE call_out_param_test1; gaussdb=# DROP PROCEDURE out_param_test1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| varray_compat                                                                 | 开启此参数后： 1. 数组类型元素赋值、元素读取行为会发生改变。  2. 调用相关数组函数行为会发生改变。  3. 开启此参数后会校验varray类型最大容量。   行为差异详情和示例具体请参见[数组](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0641.html)。 说明： - 不要在同session内切换并使用该参数。  - 升级到新版本的数据库： - 对于已经在存储过程或PACKAGE内定义好的数组类型，开启varray_compat参数不会使上述功能生效。需要重新创建数组类型，即需要重新创建存储过程或PACKAGE，执行CREATE OR REPLACE或DROP + CREATE操作来重新创建存储过程或PACKAGE从而重新创建数组类型后该参数才能生效。  - 当执行CREATE OR REPLACE PACKAGE/CREATE OR REPLACE PACKAGE BODY操作的内容与原PACKAGE/原PACKAGE BODY内容一致时，不会重新创建原数组类型，开启varray_compat参数不会使上述功能生效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| tableof_elem_constraints                                                       | 开启此参数后： 1. 集合类型会对元素合法性进行校验。  2. 索引为varchar的集合类型，索引长度也会进行合法性校验。   行为差异详情和示例具体请参见[集合](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0644.html)。 说明： - 不要在同session内切换并使用该参数。  - 对于升级新版本的数据库： - 对于已经在存储过程或PACKAGE内定义好的集合类型，开启tableof_elem_constraints参数不会使上述功能生效。需要重新创建集合类型，即需要重新创建存储过程或PACKAGE，执行CREATE OR REPLACE或DROP + CREATE操作来重新创建存储过程或PACKAGE从而重新创建集合类型后该参数才能生效。  - 当执行CREATE OR REPLACE PACKAGE/CREATE OR REPLACE PACKAGE BODY操作的内容与原PACKAGE/原PACKAGE BODY内容一致时，不会重新创建原集合类型，开启tableof_elem_constraints参数不会使上述功能生效。  - 通过CREATE TYPE type_name is table of data_type语法创建出来的集合类型，需要DROP类型后重新创建该功能才能生效。     元素合法性校验示例： 未开启此参数时调用如下存储过程，元素不校验。 ``` gaussdb=# CREATE OR REPLACE procedure p1 is gaussdb$#     type t1 is table of varchar(5); gaussdb$#     v t1 := t1(); gaussdb$# begin gaussdb$#     v.extend(); gaussdb$#     v(1) := '123456'; gaussdb$#     raise info '%', v; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CALL p1(); INFO:  {123456} p1 ---- (1 row) gaussdb=# DROP procedure p1; ```  开启此参数后调用如下存储过程，元素校验会报错。 ``` gaussdb=# SET behavior_compat_options = 'tableof_elem_constraints'; SET gaussdb=# CREATE OR REPLACE procedure p1 is gaussdb$#     type t1 is table of varchar(5); gaussdb$#     v t1 := t1(); gaussdb$# begin gaussdb$#     v.extend(); gaussdb$#     v(1) := '123456'; gaussdb$#     raise info '%', v; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CALL p1(); ERROR:  value too long for type character varying(5) CONTEXT:  PL/SQL function p1() line 5 at assignment ```  索引值合法性校验示例： 未开启该参数时，索引值超过定义长度不报错。 ``` gaussdb=# CREATE OR REPLACE procedure p1 is gaussdb$#     type t1 is table of int index by varchar(5); gaussdb$#     v t1; gaussdb$# begin gaussdb$#     v('123456') := 1; gaussdb$#     raise info '%', v; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CALL p1(); INFO:  {indexbyType:varchar,"123456"=>1} p1 ---- (1 row) gaussdb=# DROP procedure p1; ```  开启该参数后，索引值超过定义长度报错。 ``` gaussdb=# SET behavior_compat_options = 'tableof_elem_constraints'; SET gaussdb=# CREATE OR REPLACE procedure p1 is gaussdb$#     type t1 is table of int index by varchar(5); gaussdb$#     v t1; gaussdb$# begin gaussdb$#     v('123456') := 1; gaussdb$#     raise info '%', v; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# CALL p1(); ERROR:  value too long for type character varying(5) CONTEXT:  PL/SQL function p1() line 4 at assignment ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| allow_rownum_alias                                                               | 开启此参数后，将允许ROWNUM在SQL语句中通过AS语法用作列的别名，ROWNUM将作为普通标识符使用，不再能够作为伪列使用。 此参数在M-Compatibility模式数据库下不生效。 说明： 不建议在执行业务期间变更该参数的状态。开启参数的状态下，在数据库中用ROWNUM作为名称创建的数据库对象（如表名，列名，数据库名等），在参数关闭后，将会产生歧义，行为不可预期。关闭参数的状态下，在数据库中ROWNUM作为伪列使用的行为，在参数开启后，将失效，行为不可预期。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| current_sysdate                                                                   | 开启此参数后，执行sysdate时，会获取当前操作系统时间。关闭参数后，sysdate返回当前本条SQL执行时刻的系统日期和时间。 ``` gaussdb=# set behavior_compat_options='current_sysdate'; SET gaussdb=# select sysdate; current_sysdate --------------------- 2023-06-20 20:15:27 (1 row) ``` 开启GUC参数mapping_date_to_datea后，A兼容性下，sysdate会默认返回datea类型，获取当前操作系统时间，current_sysdate不再生效。 ``` gaussdb=# set behavior_compat_options=''; SET gaussdb=# show mapping_date_to_datea; mapping_date_to_datea ----------------------- on (1 row) gaussdb=# set NLS_DATE_FORMAT = 'YYYY-MM-DD HH24:MI:SS'; SET gaussdb=#  begin gaussdb$#     dbe_output.print_line('time1:' || sysdate); gaussdb$#     pg_sleep(2); gaussdb$#     dbe_output.print_line('time2:' || sysdate); gaussdb$# end; gaussdb$# / time1:2025-02-27 10:45:57 time2:2025-02-27 10:45:59 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| allow_function_procedure_replace                                                   | 默认场景下，对于A和PG兼容模式，当有一个包外的存储过程（或函数）时，创建一个同名的函数（或存储过程），与已有对象类型不同，不支持创建并报错。开启此参数后，通过create or replace的方式可以实现包外同名的存储过程和函数对象之间的类型替换。 ``` gaussdb=# create or replace function proc_test return varchar2 as gaussdb$# begin gaussdb$# return '1'; gaussdb$# end; gaussdb$# / CREATE FUNCTION gaussdb=# create or replace procedure proc_test as gaussdb$# begin gaussdb$# null; gaussdb$# end; gaussdb$# / ERROR:  cannot change routine kind DETAIL:  "proc_test" is a function. gaussdb=# \df+ proc_test List of functions Schema |   Name    | Result data type  | Argument data types |  Type  | Volatility |   Owner   | Language | Source code | Description | fencedmode | propackage | prokind --------+-----------+-------------------+---------------------+--------+------------+-----------+----------+-------------+-------------+------------+------------+--------- public | proc_test | character varying |                     | normal | volatile   | wangxinyu | plpgsql  |  DECLARE   +|             | f          | f          | f |           |                   |                     |        |            |           |          | begin      +|             |            |            | |           |                   |                     |        |            |           |          | return '1';+|             |            |            | |           |                   |                     |        |            |           |          | end         |             |            |            | (1 row) -- 设置参数后允许替换类型 gaussdb=# set behavior_compat_options='allow_function_procedure_replace'; SET gaussdb=# create or replace procedure proc_test as gaussdb$# begin gaussdb$# null; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# \df+ proc_test List of functions Schema |   Name    | Result data type | Argument data types |  Type  | Volatility |   Owner   | Language | Source code | Description | fencedmode | propackage | prokind --------+-----------+------------------+---------------------+--------+------------+-----------+----------+-------------+-------------+------------+------------+--------- public | proc_test | void             |                     | normal | volatile   | wangxinyu | plpgsql  |  DECLARE   +|             | f          | f          | p |           |                  |                     |        |            |           |          | begin      +|             |            |            | |           |                  |                     |        |            |           |          | null;      +|             |            |            | |           |                  |                     |        |            |           |          | end         |             |            |            | (1 row) gaussdb=# drop procedure proc_test; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| collection_exception_backcompat                                                 | 控制在PL/SQL中集合类型相关报错抛出的异常值，当前控制三种异常值，对应关系如下： 未开启该参数 开启该参数 collection_is_null program_limit_exceeded subscript_beyond_count program_limit_exceeded subscript_outside_limit program_limit_exceeded 用例： ``` gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1; gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v.count(); gaussdb$# exception when collection_is_null then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Reference to uninitialized collection p1 ---- (1 row) gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1 := t1(1, 2, 3); gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v(4); gaussdb$# exception when subscript_beyond_count then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Subscript beyond count p1 ---- (1 row) gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1 := t1(1, 2, 3); gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v(-1); gaussdb$# exception when subscript_outside_limit then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Subscript outside of limit p1 ---- (1 row) gaussdb=# set behavior_compat_options = 'collection_exception_backcompat'; SET gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1; gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v.count(); gaussdb$# exception when program_limit_exceeded then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Reference to uninitialized collection p1 ---- (1 row) gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1 := t1(1, 2, 3); gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v(4); gaussdb$# exception when program_limit_exceeded then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Subscript beyond count p1 ---- (1 row) gaussdb=# create or replace procedure p1 is gaussdb$#     type t1 is table of int; gaussdb$#     v t1 := t1(1, 2, 3); gaussdb$#     v_int int; gaussdb$# begin gaussdb$#     v_int := v(-1); gaussdb$# exception when program_limit_exceeded then gaussdb$#     raise info '%', sqlerrm; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# call p1(); INFO:  Subscript outside of limit p1 ---- (1 row) gaussdb=# drop procedure p1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| enable_case_when_alias                                                           | 开启该参数后，case when和decode语法的别名为以__unnamed_开头的字符串。 用例： ``` gaussdb=# set behavior_compat_options='enable_case_when_alias'; SET gaussdb=# create table test(c1 varchar2); CREATE TABLE gaussdb=# insert into test values('x'); INSERT 0 1 gaussdb=# select decode(c1,'x','0','default') from test; __unnamed_decode__ -------------------- 0 (1 row) gaussdb=# select (case c1 when 'x' then '0' else 'default' end) from test; __unnamed_case_when__ ----------------------- 0 (1 row) gaussdb=# drop table test; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| plsql_rollback_keep_user                                                        | 控制在PL/SQL中rollback和rollback to savepoint是否修改当前用户，以及rollback to定义者权限函数内的savepoint是否修改当前用户。当开启此参数时，rollback将不会修改当前用户。 用例： ``` gaussdb=# create user plsql_rollback1 PASSWORD '********'; gaussdb=# create user plsql_rollback2 PASSWORD '********'; gaussdb=# grant plsql_rollback1 to plsql_rollback2; gaussdb=# create or replace procedure plsql_rollback1.p1 () authid definer gaussdb-# as gaussdb$# va int; gaussdb$# begin gaussdb$# raise info 'current usr:%', current_user; gaussdb$# rollback; gaussdb$# raise info 'current usr:%', current_user; gaussdb$# end; gaussdb$# / CREATE PROCEDURE gaussdb=# set session AUTHORIZATION plsql_rollback2 PASSWORD '********'; SET gaussdb=> set behavior_compat_options = 'plsql_rollback_keep_user'; SET gaussdb=> call plsql_rollback1.p1 (); INFO:  current usr:plsql_rollback1 INFO:  current usr:plsql_rollback1 p1 ---- (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| enable_bpcharlikebpchar_compare                                                | 启用/关闭bpcharlikebpchar和bpcharnlikebpchar操作符。 - 新安装的数据库默认开启该参数。  - 505.1.0版本之前的数据库通过升级操作后，该参数默认关闭。   ``` gaussdb=# SELECT bpcharlikebpchar('455'::BPCHAR(10), '455  '::BPCHAR); bpcharlikebpchar ------------------ f (1 row) gaussdb=# SELECT bpcharlikebpchar('455 '::BPCHAR(10), '455 '::BPCHAR(10)); bpcharlikebpchar ------------------ t (1 row) gaussdb=# SELECT bpcharlikebpchar('455 '::BPCHAR(10), '455'::BPCHAR(10)); bpcharlikebpchar ------------------ t (1 row) gaussdb=# SELECT bpcharlikebpchar('455 '::BPCHAR(10), '455'::BPCHAR(11)); bpcharlikebpchar ------------------ f (1 row) gaussdb=# CREATE TABLE op_test ( col BPCHAR(2) DEFAULT NULL ); CREATE TABLE gaussdb=# CREATE INDEX op_index ON op_test(col); CREATE INDEX gaussdb=# INSERT INTO op_test VALUES ('a'); INSERT 0 1 gaussdb=# INSERT INTO op_test VALUES ('1'); INSERT 0 1 gaussdb=# INSERT INTO op_test VALUES ('11'); INSERT 0 1 gaussdb=# INSERT INTO op_test VALUES ('12'); INSERT 0 1 gaussdb=# INSERT INTO op_test VALUES ('sd'); INSERT 0 1 gaussdb=# INSERT INTO op_test VALUES ('aa'); INSERT 0 1 gaussdb=# SHOW behavior_compat_options; behavior_compat_options ------------------------- (1 row) --当behavior_compat_options不包含enable_bpcharlikebpchar_compare时，则未启用最新bpcharlikebpchar操作符，其bpchar匹配bpchar返回结果集非预期（正常应返回全部数据）。 gaussdb=# EXPLAIN (COSTS OFF) SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; QUERY PLAN -------------------------------------- Sort Sort Key: col ->  Seq Scan on op_test Filter: (col ~~ (col)::text) (4 rows) gaussdb=# SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; col ----- 11 12 aa sd (4 rows) gaussdb=# SET behavior_compat_options = 'enable_bpcharlikebpchar_compare'; SET gaussdb=# SHOW behavior_compat_options; behavior_compat_options --------------------------------- enable_bpcharlikebpchar_compare (1 row) --开启参数后，将启用最新bpcharlikebpchar操作符，其匹配时返回行为符合预期行为。 gaussdb=# EXPLAIN (COSTS OFF) SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; QUERY PLAN ------------------------------ Sort Sort Key: col ->  Seq Scan on op_test Filter: (col ~~ col) (4 rows) gaussdb=# SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; col ----- 1 11 12 a aa sd (6 rows) gaussdb=# DROP TABLE op_test; DROP TABLE ``` 说明： - 该参数仅在sql_compatibility兼容性参数设置为A时生效。  - 启用该参数，会影响BPCHAR类型之间进行LIKE或NOT LIKE模式匹配时的结果集与执行计划。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| cursor_asensitive                                                                | 用于游标数据敏感行为的前向兼容，集中式暂不支持该选项。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| show_full_error_lineno                                                        | 用于显示包含存储过程头部信息的行号，创建存储过程打印编译报错信息时，显示从CREATE语句开始的行号；调用有编译问题的语句时，对于非失效重编译场景，显示从CREATE语句开始的行号，失效重编译报错按照原有逻辑显示行号，调用编译显示报错信息需要开启gs_source且该表中存在存储过程的原始定义，否则按照原有逻辑显示报错行号；执行存储过程时报错，设置该参数后，显示从CREATE语句开始的行号。该参数仅在集中式下生效。 ``` gaussdb=# set behavior_compat_options='show_full_error_lineno'; gaussdb=# set plsql_compile_check_options='plsql_expression_check'; gaussdb=# CREATE OR REPLACE function proclex1(type1 int) return int is var1 int; var2 int; begin var3 := 30; --- var3未定义 return type1; end; / WARNING:  "var3" is not a known variable DETAIL:  N/A CONTEXT:  compilation of PL/pgSQL function "proclex1" near line 6 WARNING:  Function created with compilation errors. ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| enable_crosstype_integer_operator                                                  | 启用/关闭跨类型整型操作符。 - 新安装的数据库默认开启该参数。  - 505.1.0版本之前的数据库通过升级操作后，该参数默认关闭。  - 涉及操作符范围=、\<\>、\<、\>、\<=、\>=  - 开启该参数后，涉及的跨类型整型比较，不再需要隐式转换即可直接进行比较。如下以(int1 op int2)举例：   ``` gaussdb=# CREATE TABLE implicit_index(c1 int1); CREATE TABLE gaussdb=# CREATE INDEX idx1 ON implicit_index(c1); CREATE INDEX gaussdb=# SET behavior_compat_options='enable_crosstype_integer_operator'; SET gaussdb=# EXPLAIN SELECT * FROM implicit_index WHERE c1 = 1::int2; QUERY PLAN --------------------------------------------------------------------------------- [Bypass] Index Only Scan using idx1 on implicit_index  (cost=0.00..4.48 rows=13 width=1) Index Cond: (c1 = 1::smallint) (3 rows) gaussdb=# SET behavior_compat_options=''; SET gaussdb=# EXPLAIN SELECT * FROM implicit_index WHERE c1 = 1::int2; QUERY PLAN ---------------------------------------------------------------- Seq Scan on implicit_index  (cost=0.00..49.52 rows=13 width=1) Filter: ((c1)::bigint = 1::smallint) (2 rows) gaussdb=# DROP TABLE implicit_index; DROP TABLE ``` 说明： - 该参数仅在sql_compatibility兼容性参数设置为A时生效。  - 启用该参数，会影响涉及如下场景的操作符的执行计划： - (int1 op int2)  - (int1 op int4)  - (int1 op int8)  - (int1 op int16)  - (int1 op numeric)  - (int2 op int1)  - (int2 op int16)  - (int2 op numeric)  - (int4 op int1)  - (int4 op int16)  - (int4 op numeric)  - (int8 op int1)  - (int8 op int16)  - (int8 op numeric)  - (int16 op int1)  - (int16 op int2)  - (int16 op int4)  - (int16 op int8)  - (numeric op int1)  - (numeric op int2)  - (numeric op int4)  - (numeric op int8)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| forbid_package_function_with_prefix                                            | 打开该参数后，创建package内的函数时，如果函数有前缀，则会报错。 例如： ``` --打开参数 gaussdb=# SET behavior_compat_options='forbid_package_function_with_prefix'; SET --创建SCHEMA sch1 gaussdb=# CREATE SCHEMA sch1; --创建PACKAGE后报错 gaussdb=# CREATE PACKAGE pck1 IS PROCEDURE sch1.pck1(); END pck1; / ERROR:  not support procedure name use *.* format in package at or near ";" CONTEXT:  compilation of PL/pgSQL package near line 1 --删除SCHEMA sch1 gaussdb=# DROP SCHEMA sch1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| time_constexpr_compact                                                            | 打开该参数后，执行时间表达式场景，会根据常量是否携带时区，自动返回with timezone类型或without timezone类型。 目前支持timestamp类型、time类型。 ``` --执行不带时区的时间戳表达式。 gaussdb=# SELECT timestamp '1999-03-15 8:00:00'; timestamp --------------------- 1999-03-15 08:00:00 (1 row) --执行带时区的时间戳表达式 返回timestamp with time zone类型。 gaussdb=# SELECT timestamp '1999-03-15 8:00:00 -8:00:00'; timestamptz ------------------------ 1999-03-16 00:00:00+08 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| enable_use_ora_timestamptz                                                      | 开启后TIMESTAMP AT TIME ZONE语法得到的日期时间跟A数据库保持一致。由于GaussDB只能显示session时区，A可以显示输入的时区，当时区不一致时显示的结果不同，将日期时间转换到相同时区后是同一时间点。 ``` --打开参数前 gaussdb=# SELECT timestamp '2024-03-20 01:30:00' at time zone 'Europe/Moscow' FROM dual; timezone ---------------------- 2024-03-20 06:30:00+08 (1 row) -- 打开参数后 gaussdb=# SET behavior_compat_options='enable_use_ora_timestamptz'; SET gaussdb=# SELECT timestamp '2024-03-20 01:30:00' at time zone 'Europe/Moscow' FROM dual; timezone ---------------------- 2024-03-20 01:30:00+08 (1 row) ``` 说明： 该参数仅在数据库兼容性为A时有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| forbid_skip_tableof_empty_str_elem                                            | 用于控制无索引的集合类型对于'{1,,3}'格式字符串的输入行为。 - 打开该参数后，无索引的集合型将不支持'{1,,3}'格式字符串的输入。 ``` gaussdb=# CREATE TYPE t1 IS TABLE OF int; CREATE TYPE gaussdb=# CREATE OR REPLACE PROCEDURE p1(v t1) IS gaussdb$# BEGIN gaussdb$#      FOR i IN 1..v.count LOOP gaussdb$#          dbe_output.print_line('v(' || i || ') is ' || v(i)); gaussdb$#      END LOOP; gaussdb$# END; gaussdb$# / CREATE PROCEDURE gaussdb=# SET behavior_compat_options = 'forbid_skip_tableof_empty_str_elem'; SET gaussdb=# CALL p1('{1,,3}'); ERROR:  Malformed nesttable literal: "{1,,3}". LINE 1: call p1('{1,,3}'); ^ gaussdb=# CALL p1('{1,}'); ERROR:  Malformed nesttable literal: "{1, }". LINE 1: call p1('{1, }'); ^ gaussdb=# CALL p1('{,3}'); ERROR:  Malformed nesttable literal: "{ ,3}". LINE 1: call p1('{ ,3}'); ^ gaussdb=# DROP PROCEDURE p1; DROP PROCEDURE gaussdb=# DROP TYPE t1; DROP TYPE ```   - 关闭该参数后，无索引的集合型将支持'{1,,3}'格式字符串的输入，在进行转换时会自动过滤空字符串。 ``` gaussdb=# CREATE TYPE t1 IS TABLE OF int; CREATE TYPE gaussdb=# CREATE OR REPLACE PROCEDURE p1(v t1) IS gaussdb$# BEGIN gaussdb$#      FOR i IN 1..v.count LOOP gaussdb$#          dbe_output.print_line('v(' || i || ') is ' || v(i)); gaussdb$#      END LOOP; gaussdb$# END; gaussdb$# / CREATE PROCEDURE gaussdb=# SET behavior_compat_options = ''; SET gaussdb=# CALL p1('{1,,3}'); v(1) is 1 v(2) is 3 p1 ---- (1 row) gaussdb=# CALL p1('{1,}'); v(1) is 1 p1 ---- (1 row) gaussdb=# CALL p1('{,3}'); v(1) is 3 p1 ---- (1 row) gaussdb=# DROP PROCEDURE p1; DROP PROCEDURE gaussdb=# DROP TYPE t1; DROP TYPE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| sys_function_without_brackets                                                      | 开启该参数后，对于A兼容模式下无入参系统函数，可以不带括号进行调用。 ``` gaussdb=# SET behavior_compat_options='sys_function_without_brackets'; gaussdb=# SELECT systimestamp; systimestamp ------------------------------- 2024-04-16 15:55:21.614342+08 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| array_count_compat                                                              | 用于决定变长数组类型的变量为NULL时，调用array_count函数的返回值为NULL值还是0值。 - 开启参数后，变长数组类型的变量为NULL时，array_count函数返回值为0值。 ``` gaussdb=# create type t1 as table of int; CREATE TYPE gaussdb=# set behavior_compat_options='array_count_compat'; SET gaussdb=# gaussdb=# declare gaussdb-# type typ is varray(5) of int; gaussdb-# va typ; gaussdb-# begin gaussdb$# raise info 'va count:%',va.count; gaussdb$# if 1 > va.count then gaussdb$# raise info ' 1 > null is true'; gaussdb$# else gaussdb$# raise info ' 1 > null is false'; gaussdb$# end if; gaussdb$# end; gaussdb$# / INFO:  va count:0 INFO:   1 > null is true ANONYMOUS BLOCK EXECUTE ```   - 关闭参数后，变长数组类型的变量为NULL时，array_count函数返回值为NULL值。 ``` gaussdb=# set behavior_compat_options=''; SET gaussdb=# create type t1 as table of int; CREATE TYPE gaussdb=# declare gaussdb-# type typ is varray(5) of int; gaussdb-# va typ; gaussdb-# begin gaussdb$# raise info 'va count:%',va.count; gaussdb$# if 1 > va.count then gaussdb$# raise info ' 1 > null is true'; gaussdb$# else gaussdb$# raise info ' 1 > null is false'; gaussdb$# end if; gaussdb$# end; gaussdb$# / INFO:  va count:<NULL> INFO:   1 > null is false ANONYMOUS BLOCK EXECUTE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| search_path_behavior_optimization                                                 | 启用/关闭存储过程搜索路径增强功能。 - 新安装的数据库默认关闭该参数。  - 开启该选项后，选项包含bind_procedure_searchpath选项能力。存储过程中会绑定会话级别search_path设置中的Schema，形成一份Schema列表。存储过程内未显式指定Schema的对象，会在这份Schema列表中按照顺序依次查找。如果同时开启bind_procedure_searchpath和search_path_behavior_optimization选项，默认使用search_path_behavior_optimization选项。  - 开启该选项后，与单独开启bind_procedure_searchpath选项的区别在于：搜索路径编译产物中$user的刷新逻辑变化，以及搜索路径编译产物中pg_temp schema的存在变化。  - 开启该选项后，具体行为变更如下： - 嵌套调用SECURITY DEFINER函数刷新搜索路径编译产物中的$user为嵌套最内层的函数owner。  - 本地临时表的namespace不加入搜索路径编译产物。  - 不支持存储过程/函数使用本地临时表%type、%rowtype写法（该限制不适用于本地临时表%type、%rowtype作为入参、出参场景）。例如： ``` gaussdb=# SET behavior_compat_options='search_path_behavior_optimization'; SET -- 创建本地临时表temp_table gaussdb=# CREATE TEMP TABLE tmp_table(c1 int); CREATE TABLE -- 存储过程内使用本地临时表%rowtype写法，报错 gaussdb=# CREATE or REPLACE PROCEDURE test_temp_tab_proc AS gaussdb$# a tmp_table%ROWTYPE; gaussdb$# BEGIN gaussdb$# NULL; gaussdb$# END; gaussdb$# / ERROR:  UNSUPPORTED FEATURE with temporary table when setting behavior_compat_options: search_path_behavior_optimization. CONTEXT:  compilation of PL/pgSQL function "test_temp_tab_proc" near line 2 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| forbid_update_multi_same_tables                                                  | 开启该参数后，对于UPDATE多表语法，不允许同时更新多张相同的表。 ``` gaussdb=# CREATE TABLE t_multi_t1(c1 int, c2 int); CREATE TABLE gaussdb=# UPDATE t_multi_t1 a,t_multi_t1 b set b.c1 = 10, a.c2 = 200; ERROR:  Update failed when contains multiple same tables. DETAIL:  When behavior_compat_options is set to forbid_update_multi_same_tables, update operation will fail when contains multiple same tables. gaussdb=# DROP TABLE t_multi_t1; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| enable_ora_joinop_in_updatestmt                                                 | 用于控制在UPDATE语句中SET子句带子查询时，子查询是否支持"+"操作符。 开启该参数后，子查询返回的是带"+"的结果： ``` gaussdb=# SET behavior_compat_options='enable_ora_joinop_in_updatestmt'; gaussdb=# DROP TABLE t1; gaussdb=# DROP TABLE t2; gaussdb=# DROP TABLE t3; gaussdb=# CREATE TABLE t1(a1 int, b int); CREATE TABLE gaussdb=# CREATE TABLE t2(c1 int, d int); CREATE TABLE gaussdb=# CREATE TABLE t3(a2 int, c2 int, e int); CREATE TABLE gaussdb=# INSERT INTO t1 VALUES(1, 11),(2, 12); INSERT 0 2 gaussdb=# INSERT INTO t2 VALUES(3, 23),(4, 24); INSERT 0 2 gaussdb=# INSERT INTO t3 VALUES(1, 3, 31),(5, 6, 32); INSERT 0 2 gaussdb=# CREATE TABLE result(col1 int, col2 int, col3 int, col4 int, col5 int,col6 int, col7 int); CREATE TABLE gaussdb=# INSERT INTO result SELECT * FROM t1, t2, t3 WHERE t1.a1=t3.a2 AND t2.c1=t3.c2; INSERT 0 1 gaussdb=# UPDATE  result SET (col1, col2, col3, col4 ,col5,col6,col7) = ( SELECT a1,b,c1,d,a2,c2,e FROM t1, t2, t3 WHERE t1.a1=t3.a2(+) AND t3.c2=t2.c1(+)); ERROR: The subquery in the expression returns more than one row of result. CONTEXT:  referenced column: col1 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| disable_insert_void_value                                                       | 用于控制void类型的返回值能否执行INSERT或UPDATE，A兼容性下生效。 开启该参数后void类型执行INSERT或UPDATE失败，关闭时允许执行INSERT或UPDATE。 ``` gaussdb=# SELECT pg_typeof(dbe_application_info.set_action(''::text)); pg_typeof ----------- void (1 row) gaussdb=# SET behavior_compat_options = 'disable_insert_void_value'; gaussdb=# CREATE TABLE insert_void (id int,col text); gaussdb=# INSERT INTO insert_void (id,col) VALUES(1,dbe_application_info.set_client_info(''::text)); ERROR:  column "col" is of type text but expression is of type void LINE 1: INSERT INTO insert_void (id,col) VALUES(1,dbe_application_in... ^ HINT:  You will need to rewrite or cast the expression. CONTEXT:  referenced column: col gaussdb=# UPDATE insert_void SET col  = dbe_application_info.set_client_info(''::text); ERROR:  column "col" is of type text but expression is of type void LINE 1: UPDATE insert_void SET col  = dbe_application_info.set_clie... ^ HINT:  You will need to rewrite or cast the expression. CONTEXT:  referenced column: col ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| ignore_like_default_escape                                                    | 用于LIKE模糊匹配时，控制模式串中的反斜杠'\\'是否被视为转义字符。 该参数仅在standard_conforming_strings为on时才可以被设置。 - 开启参数后，LIKE模糊匹配中，支持将模式串中的反斜杠字符'\\'视为普通字符去匹配，'\\'不起转义作用，无法消除通配符的特殊含义。 ``` gaussdb=# SET standard_conforming_strings = on; SET gaussdb=# SET behavior_compat_options = 'ignore_like_default_escape'; SET gaussdb=# CREATE TABLE test(c1 text); CREATE TABLE gaussdb=# INSERT INTO test VALUES('aa\a'); INSERT 0 1 gaussdb=# SELECT * FROM test WHERE c1 LIKE 'aa\a'; c1 ------ aa\a (1 row) gaussdb=# DROP TABLE test; DROP TABLE ```     - 关闭参数后，LIKE模糊匹配中，模式串中的反斜杠字符'\\'视为转义字符，'\\'起转义作用，可以消除通配符的特殊含义。 ``` gaussdb=# SET behavior_compat_options = ''; SET gaussdb=# CREATE TABLE test(c1 text); CREATE TABLE gaussdb=# INSERT INTO test VALUES('aaa'); INSERT 0 1 gaussdb=# SELECT * FROM test WHERE c1 LIKE 'aa\a'; c1 ------ aaa (1 row) gaussdb=# DROP TABLE test; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据数据库兼容对象进行调整。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
该参数的部分选项值影响缓存计划，在prepare语句下，修改该参数的值，执行结果不会改变。
#### plsql_compile_check_options
**参数说明：**数据库兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表5]，当设置多个兼容性配置项时，相邻配置项用逗号隔开，例如：set plsql_compile_check_options='for_loop,outparam'。
**默认值：**''。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 表5兼容性配置项 
| **兼容性配置项**              | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
|:---|:---|
| for_loop                | 控制存储过程中FOR_LOOP查询语句行为。设置此项时，在FOR rec IN query LOOP语句中，若rec已经定义，不会复用已经定义的rec变量，而是重新建立一个新的变量。否则，会复用已经定义的rec变量，不会建立新的变量。(与proc_implicit_for_loop_variable相同，后续进行收编)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| outparam              | 可能存在多个同名但输出参数列表不同的重载函数，若开启该选项，将对out出参进行检查，out出参为常量时报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| plsql_expression_check | 开启plsql_expression_check参数。 校验函数、存储过程和PACKAGE中的全量语句。当存在未定义的对象时（例如表不存在，变量不存在，函数不存在），会打印告警信息。 说明： - SQL语句提供校验功能，仅支持SELECT、INSERT、UPDATE、DELETE、MERGE。其余DDL、DML不支持。  - 动态SQL不进行校验。  - 存在误报情况，误报会导致函数、存储过程和PACKAGE新建出现告警，失效重编译出现告警、pg_object的valid字段为false。所以推荐测试环境使用，修改函数、存储过程和PACKAGE定义，提高问题定位效率。生产中不推荐使用。   校验功能举例： ``` gaussdb=# CREATE OR REPLACE procedure proc1() AS var1 int; begin SELECT id into var1 from table1_not_exist limit 1;--表不存在，有告警信息 SELECT id into var1 from view1_not_exist limit 1;--视图不存在，有告警信息 var1 := func_input1(func1_not_exist());--函数不存在，有告警信息 var1 := pkg.var1_not_exist;--package变量不存在，有告警信息 end; / ``` 执行结果如下：新建成功，打印告警信息 ``` WARNING:  compile failed when parse the query: select id           from table1_not_exist limit 1, error info is relation "table1_not_exist" does not exist on datanode DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 3 WARNING:  compile failed when parse the query: select id           from view1_not_exist limit 1, error info is relation "view1_not_exist" does not exist on datanode DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 4 WARNING:  compile failed when parse the query: SELECT func_input1(func1_not_exist()), error info is function func1_not_exist() does not exist DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 5 WARNING:  compile failed when parse the query: SELECT pkg.var1_not_exist, error info is missing FROM-clause entry for table "pkg" DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 6 WARNING:  Procedure created with compilation errors. CREATE PROCEDURE ``` 存在误报情况： 示例1： ``` gaussdb=# CREATE TABLE emp(deptno smallint, ename char(100), salary int); gaussdb=# CREATE TABLE emp_back(deptno smallint, ename char(100), salary int); gaussdb=# CREATE OR REPLACE PROCEDURE proc_200() As BEGIN for data in delete from emp returning * loop INSERT INTO emp_back values(data.deptno,data.ename,data.salary);--此处误报 END LOOP; END; / WARNING:  compile failed when parse the query: INSERT INTO emp_back values(data.deptno,data.ename,data.salary), error info is record "data" is not assigned yet when get datum type info DETAIL:  N/A CONTEXT:  compilation of PL/pgSQL function "proc_200" near line 4 WARNING:  Procedure created with compilation errors. CREATE PROCEDURE ``` 示例2： ``` gaussdb=# CREATE OR REPLACE procedure proc1() is BEGIN DROP TABLE if exists table1; CREATE TABLE table1(id int); INSERT INTO table1 values(1);--此处会误判断错误，table1不存在。 END; / WARNING:  compile failed when parse the query: insert into table1 values(1), error info is relation "table1" does not exist on datanode DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 2 WARNING:  Procedure created with compilation errors. CREATE PROCEDURE --pg_object对应的状态为无效。 gaussdb=# SELECT object_type,valid from pg_object obj join pg_proc proc on  obj.object_oid = proc.oid and proc.proname = 'proc1'; object_type | valid -------------+------- P           | f (1 row) gaussdb=# ALTER procedure proc1 compile; WARNING:  compile failed when parse the query: insert into table1 values(1), error info is relation "table1" does not exist on datanode DETAIL:  N/A CONTEXT:  compilation of PL/SQL function "proc1" near line 5 WARNING:  Procedure proc1 recompile with compilation errors. ALTER PROCEDURE gaussdb=# SELECT object_type,valid from pg_object obj join pg_proc proc on  obj.object_oid = proc.oid and proc.proname = 'proc1'; object_type | valid -------------+------- P           | f (1 row) gaussdb=# CALL proc1(); NOTICE:  table "table1" does not exist, skipping CONTEXT:  SQL statement "drop table if exists table1" PL/SQL function proc1() line 3 at SQL statement proc1 ------- (1 row) gaussdb=# SELECT object_type,valid from pg_object obj join pg_proc proc on  obj.object_oid = proc.oid and proc.proname = 'proc1'; object_type | valid -------------+------- P           | t (1 row) ``` 该参数在新建函数、存储过程、PACKAGE，以及重编译函数、存储过程、PACKAGE时，会执行校验的功能。误报会导致pg_object的valid字段变为false。 执行阶段，不进行校验。执行成功时，pg_object的valid字段变为true。 |
   
 #### a_format_version
**参数说明：**数据库平台兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表6]。
**默认值：**"10c"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 表6兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                       |
|:---|:---|
| 10c       | A平台兼容版本。由于a_format_version和a_format_dev_version一起使用，详细的行为控制见[表7]。 |
   
 #### a_format_dev_version
**参数说明：**数据库平台迭代小版本兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表7]。
**默认值：**"s7"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 表7兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|
| s1          | - A平台兼容迭代小版本，影响函数（round(date, fmt),nvl2,lpad,rpad,add_months,months_between,regexp_replace,regexp_count,empty_clob,instrb,trunc(numeric, int),greatest,least,mod,round(number, int),cast,to_date,to_timestamp,chr,to_char,to_number，to_timestamp_tz）。 - round(date, fmt)：此函数的入参为timestamp without time zone时，在A兼容模式数据库中且参数a_format_version值为10c和a_format_dev_version值为s1的情况下有效。  - nvl2：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下有效。  - lpad：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下： - 参数length表示字符串显示长度，单个字符的显示长度按照A兼容处理。  - 函数执行过程中出现length剩余长度为1且下一个字符显示长度为2，在字符串左侧添加一个空格字符。    - 参数length入参若为小数则不会被四舍五入，而是被截断。  - 参数string与fill不支持不符合编码规范的输入。    - rpad：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下： - 参数length表示字符串显示长度，单个字符的显示长度按照A兼容处理。  - 函数执行过程中出现length剩余长度为1且下一个字符显示长度为2，在字符串右侧添加一个空格字符。    - 参数length入参若为小数则不会被四舍五入，而是被截断。  - 参数string与fill不支持不符合编码规范的输入。  - 参数string有长度限制，若填充后大小超出1G会报错。    - add_months：此函数在GUC参数mapping_date_to_datea值为off的情况下，数据库会将入参中的date类型解析为timestamp(0) without time zone类型，此时返回值为timestamp类型。当该函数入参类型被解析为timestamp(0) without time zone时，此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下： - 当计算结果大于公元9999年时会报错。    - 参数n入参若为小数则不会被四舍五入，而是被截断    - months_between：此函数在GUC参数mapping_date_to_datea值为off的情况下，数据库会将入参中的date类型解析为timestamp(0) without time zone类型。当该函数入参类型被解析为timestamp(0) without time zone时，此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下有效。  - regexp_replace：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下，occurrence参数默认值为0，表示替换所有匹配到的子串。并且以'\\'字符结尾的pattern参数为合法的。  - regexp_count：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下，以'\\'字符为结尾的pattern参数为合法的。  - empty_clob：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下有效。  - instrb：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下有效。  - trunc(numeric, int)：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1时，参数s若入参为小数则不会被四舍五入，而是被截断。  - greatest：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下： - 如果参数中有任意一个参数的值为NULL，函数返回NULL。  - 如果第一个参数是数值类型，函数将第一个参数和其他参数都转换为numeric类型，然后进行比较，对于不能转换的，提示出错信息；第一个参数是其他类型的，函数将其他参数都转换为第一个参数的类型进行比较，对于不能转换的，提示出错信息。    - least：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s1的情况下： - 如果参数中有任意一个参数的值为NULL，函数返回NULL。  - 如果第一个参数是数值类型，函数将第一个参数和其他参数都转换为numeric类型，然后进行比较，对于不能转换的，提示出错信息；第一个参数是其他类型的，函数将其他参数都转换为第一个参数的类型进行比较，对于不能转换的，提示出错信息。    - mod：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s6的情况下，支持mod(text, int)重载，在以(text, int)为入参类型调用mod函数时，会优先选择mod(text, int)  - round(numeric, int)： - 控制参数s输入为小数时：在A兼容模式数据库中且参数a_format_version值为10c和a_format_dev_version值为s1的情况下s截断为整数，否则s四舍五入为整数。  - 在参数a_format_version值为10c和a_format_dev_version值为s1的情况下，round函数支持round(timestamp, text)重载，在以(text, text)或(text, '')为入参调用round函数时会优先选择round(timestamp, text)。    - cast：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下，支持DEFAULT z ON CONVERSION ERROR的可选语法及fmt可选参数  - to_date：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下，年份的输入超过9999时，系统可能不报错。如to_date('99999-12-12', 'yyyy-mm-dd hh24:mi:ss')结果为9999-09-12 12:00:00。年输入超过9999时，超过4位后面的数字会解析为下一个fmt。  - to_timestamp：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下，fmt支持FF\[7-9\]，在FF\[7-9\]的情况下允许转换string中的对应位置长度小于等于FF紧跟的数字，但最终转换结果长度最大保留6位。  - chr：此函数在A兼容模式数据库中且参数a_format_version值为10c和a_format_dev_version值为s1的情况下：参数integer入参若为小数则不会被四舍五入，而是被截断。  - to_char(numeric/smallint/integer/bigint/double precision/real\[, fmt\])：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下，支持$、C、TM、TM9、TME、U格式。同时在该参数下，不支持TH、PL、SG格式的fmt。  - to_number：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下，to_number函数的格式fmt详情可参考《开发指南》中的to_number函数介绍。  - to_timestamp_tz：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s1的情况下有效。    - 数据类型转换：小数字符串转换成整数类型（int1/int2/int4/int8/int16）时进行四舍五入。  - 数据类型转换：支持timestamp with time zone到timestamp without time zone和datea，以及timestamp到datea的隐式转换。   |
| s2        | - A平台兼容迭代小版本，影响函数（dump, to_single_byte, to_multi_byte, nls_upper, nls_lower, initcap, ascii2, asciistr, unistr, vsize, cosh, remainder, sinh, tanh, nanvl, current_date, current_timestamp, dbtimezone, numtodsinterval, numtoyminterval, new_time, sessiontimezone, sys_extract_utc, tz_offset, to_binary_double, to_binary_float, to_dsinterval, to_yminterval, lnnvl, ora_hash, rawtohex2, bit2coding, bit4coding）。 - dump：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - to_single_byte：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - to_multi_byte：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - nls_upper：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下支持使用。  - nls_lower：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下支持使用。  - initcap：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下，如中文等无大小写区分的字符后接区分大小写的字符首字母会转换为大写，其他字母转换为小写。因此建议开启参数a_format_version值为10c和a_format_dev_version值为s2。  - ascii2：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - asciistr：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - unistr：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - vsize：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - cosh：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - remainder：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - sinh：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - tanh：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - nanvl：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - current_date：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下返回值类型为timestamp。  - current_timestamp：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2时，precision参数支持numeric类型的整值，否则仅支持int输入。  - dbtimezone：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - numtodsinterval：此函数在A兼容模式下，_format_version值为10c和a_format_dev_version值为s2的情况下：当参数interval_unit为 'DAY' 时，参数num超过1000000000会报错。  - numtoyminterval：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - new_time：此函数GUC参数mapping_date_to_datea值为off的情况下，数据库会将入参中的date类型解析为timestamp(0) without time zone类型，此时返回值为timestamp类型。当该函数入参类型被解析为timestamp(0) without time zone时，此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - sessiontimezone：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - sys_extract_utc：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - tz_offset：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - to_binary_double：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s2的情况下有效。  - to_binary_float：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s2的情况下有效。  - to_dsinterval：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s2的情况下有效。  - to_yminterval：此函数在A兼容模式下，a_format_version值为10c且a_format_dev_version值为s2的情况下有效。  - lnnvl：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下有效。  - ora_hash：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下才能有效。  - rawtohex2：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下才能有效。  - bit2coding：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下才能有效。  - bit4coding：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s2的情况下才能有效。    - 兼容配置项为s1时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| s3        | - A平台兼容迭代小版本，开启参数，支持无参函数嵌套调用。  - 兼容配置项为s2时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| s4         | - A平台兼容迭代小版本，影响函数nchr(cvalue int\|bigint)、to_timestamp_tz、getclobval(xml)、getstringval(xml)。 - nchr(cvalue int\|bigint)：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s4的情况下有效。  - to_timestamp_tz(string \[DEFAULT return_value ON CONVERSION ERROR\], fmt, nlsparam)：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s4的情况下有效。  - getclobval(xml)：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s4的情况下有效。  - getstringval(cml)：此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s4的情况下有效。    - 兼容配置项为s3时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| s5        | - A平台兼容迭代小版本，开启参数，支持复合类型与函数同名，优先解析为复合类型，影响函数sys_guid()。 - 此函数在A兼容模式下，a_format_version值为10c和a_format_dev_version值为s5的情况下才能生效。    - 兼容配置项为s4时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| s6        | - A平台兼容迭代小版本，开启参数，影响函数mod(text, int)。 - mod(text, int)：此函数在A兼容模式数据库下且在参数a_format_version值为10c和a_format_dev_version值为s6的情况下，mod函数支持mod(text, int)重载，在以(text, int)为入参类型调用mod函数时，会优先选择mod(text, int)。    - 兼容配置项为s5时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| s7          | - A平台兼容迭代小版本，开启参数。  - 当开启该参数时： 1. 兼容GUC参数配置为behavior_compat_options='display_leading_zero, end_month_calculate, plstmt_implicit_savepoint, truncate_numeric_tail_zero, char_coerce_compat, rownum_type_compat, aformat_null_test, aformat_regexp_match, disable_rewrite_nesttable, compat_cursor, allow_procedure_compile_check, plsql_security_definer, proc_outparam_override, proc_implicit_for_loop_variable, dynamic_sql_compat, proc_outparam_transfer_length, varray_compat, tableof_elem_constraints, current_sysdate, plsql_rollback_keep_user, enable_bpcharlikebpchar_compare, show_full_error_lineno, enable_crosstype_integer_operator, forbid_package_function_with_prefix, enable_case_when_alias, time_constexpr_compact, enable_use_ora_timestamptz, forbid_skip_tableof_empty_str_elem, sys_function_without_brackets'的所有行为，具体请参见[平台和客户端兼容性](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1043.html)。  2. 兼容GUC参数配置为a_format_copy_version='s1'的所有行为， 具体请参见[a_format_copy_version]。  3. 兼容GUC参数配置为a_format_date_timestamp=on的所有行为，具体请参见[a_format_date_timestamp]。    - 兼容配置项为s6时的所有行为。  - JDBC驱动连接数据库的场景，若需要设置该参数，需同步更新JDBC驱动。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
   
 #### b_format_version
**参数说明：**数据库平台兼容性行为配置项，用于控制B兼容模式下的前向兼容性。该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 仅当[sql_compatibility]兼容性参数设置为B时，b_format_version参数才会生效。
- 当该参数设置为非空字符串时，会同时设置参数[b_format_behavior_compat_options]为"ALL"值，参数[bytea_output](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1037.html#ZH-CN_TOPIC_0000002764300534__zh-cn_topic_0283136752_zh-cn_topic_0237124732_zh-cn_topic_0059779117_sb95ebefb0b624975b0714dfe8e0ec15c)为"escape"值。当该参数重新设置为空字符串时，会将b_format_behavior_compat_options、bytea_output参数设为原来的值。
 
**参数类型：**字符串
**参数单位：**无
**取值范围：**空字符串""或"5.7"
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 与[b_format_dev_version]一起设置，在安装部署后立即设置，后期非必要无需变更。
**设置不当的风险与影响：**影响部分SQL的行为，导致兼容性问题。
 #### b_format_dev_version
**参数说明：**数据库平台迭代小版本兼容性行为配置项。该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
当[sql_compatibility]兼容性参数设置为B且[b_format_version]设置为"5.7"时，b_format_dev_version才会生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 空字符串""或 [表8]中的兼容性配置项。
 表8兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|
| s1       | 1. 影响如下参数： 参数打开会将disable_keyword_options参数中的datetime选项去除，表示datetime作为非保留关键字使用。datetime可以作为表名、列名、别名使用，但不能作为函数名、存储过程名、函数或存储过程的参数名使用。   2. 影响如下函数： curdate，from_days，date_format，str_to_date，current_date，datediff，timestampdiff，date_add，subtime，month，time_to_sec，to_days，to_seconds，dayname，monthname，convert_tz，sec_to_time，addtime，adddate，date_sub，timediff，last_day，weekday，from_unixtime，unix_timestamp，subdate，day，year，weekofyear，dayofmonth，dayofyear，week，yearweek，dayofweek，time_format，hour，minute，second，microsecond，quarter，utc_date，get_format，extract，makedate，period_add，timestamppadd，period_diff，utc_time，utc_timestamp，sysdate，current_timestamp，maketime，curtime，current_time，localtime，localtimestamp，now，lc_time_names，default_week_format，json_object，substring。   3. 影响如下类型： 1. 兼容整型类型tinyint，范围变更为-128 \~ 127。  2. 兼容字符串类型char、varchar，char(n)和varchar(n)的精度n由字节长度变为字符长度。  3. 兼容文本类型tinytext、mediumtext和longtext。这些类型在开启参数后会被映射为text类型。  4. 兼容二进制类型tinyblob、blob、mediumblob和longblob。这些类型在开启参数后会被映射为bytea类型。  5. 兼容浮点类型double、float和real。double映射为float8类型，double(p, s)映射为numeric类型，float(p, s)映射为numeric类型，real映射为float8，real(p, s)映射为numeric类型。  6. 兼容高精度类型numeric、dec和decimal。未指定精度和标度时变更默认精度为10，标度为0。  7. 兼容时间类型datetime、timestamp、time和date。datetime\[(p)\]替换成timestamp without time zone\[(p)\]类型。timestamp\[(p)\]替换成timestamp with time zone\[(p)\]类型。这些类型的输入输出、范围、精度等规格有变更，具体请参见[数据类型](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0004.html)。  8. 兼容整型类型tinyint、smallint、int、bigint，这些类型在开启参数后显示宽度和ZEROFILL属性功能生效。    4. 影响如下语法： 支持指定列约束ON UPDATE update_expr。   5. 影响如下操作符： 1. 使用bytea类型间的\|\|操作符报错。  2. 支持REGEXP操作符。    6. 影响如下GUC参数： 参数bytea_output='escape'时，处理逻辑发生变化，具体请参见[bytea_output](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1037.html#ZH-CN_TOPIC_0000002764300534__zh-cn_topic_0283136752_zh-cn_topic_0237124732_zh-cn_topic_0059779117_sb95ebefb0b624975b0714dfe8e0ec15c)参数内容。    |
| s2       | 包含s1控制的兼容性行为，此外还包含以下影响： 1. 影响如下参数： 1. 此选项打开时，auto_increment_cache参数功能才会生效。  2. 此选项打开时，multi_insert_min_rows参数功能对自动增长列生效。  3. 此选项打开时，standard_conforming_strings、escape_string_warning参数被置为off。  4. 此选项打开时，collation_connection、character_set_connection参数功能才会生效。    2. 影响如下功能： 1. AUTO_INCREMENT自动增长列在导入数据或者进行BATCH INSERT执行计划的插入操作时，对于混合0、NULL和确定值的场景，确定值插入时会立即更新自增计数，后续的0/NULL将在确定值的基础上自增。  2. like操作符对于匹配串末尾是转义符的场景不再报错。  3. 字符集、字符序的排序规则优先级将发生变更，具体请参见[字符集和字符序合并规则](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0037.html)。  4. 打开参数后，不支持外键字符序和列上字符序不一致。    3. 影响如下语法： 1. 支持"CREATE TABLE table_name LIKE source_table"语法。  2. "CREATE TABLE table_name LIKE source_table"和"CREATE TABLE table_name (LIKE source_table)"语法不支持指定INCLUDING和EXCLUDING选项，缺省等同于指定INCLUDING ALL。  3. 支持LOAD DATA语法，gs_loader中部分与LOAD DATA语法一致的语法功能会发生变化。  4. 支持set names指定collate子句。  5. 涉及ALTER TABLE，RENAME TABLE等更改表名的语法，影响场景如下： 新表名对应字符串开头为"#MySQL50#"，且其后有其他字符，"#MySQL50#"将被忽略。 如果新旧表名一致，不会报错。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
   
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 与[b_format_version]一起设置，在安装部署后立即设置，后期非必要无需变更。
**设置不当的风险与影响：**影响部分SQL的行为，导致兼容性问题。
 #### m_format_dev_version
**参数说明：**数据库平台迭代小版本兼容性行为配置项。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
当[sql_compatibility]兼容性参数设置为M时，m_format_dev_version才会生效。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 空字符串""或[表9]中的兼容性配置项。
 表9兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|:---|:---|
| s1          | 影响如下语法： 1. 禁用SELECT FETCH FIRST ROWS ONLY语法。  2. 禁用TRUNCATE CASCADE/RESTRICT语法。  3. 禁用CREATE TABLE中定义主键时指定USING INDEX TABLESPACE tablespace_name语法。  4. DROP TABLE/VIEW/COLUMN中CASCADE/RESTRICT语法语义改变，改为忽略CASCADE/RESTRICT的语义，且默认行为为RESTRICT。  5. CREATE TABLE REFERENCES作为列约束时，语法语义改变，改为忽略该外键定义。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| s2          | 影响如下操作符： 1. ::操作符的转换规则变更为默认隐式转换规则。   影响如下视图： 1. information_schema.statistics视图内INDEX_NAME字段在主键场景由显示primary改为显示PRIMARY；COLUMN_NAME和SUB_PART字段补充了前缀索引场景的支持；临时表索引由显示改为不显示;系统列的索引由部分场景可能会显示改为不显示。  2. information_schema.global_variables视图内数据由显示pg_settings表里面所有数据缩小为pg_settings表里context字段是"internal"、"postmaster"、"backend"、"sighup"数据。  3. information_schema.columns视图内COLUMN_KEY字段补充了前缀索引场景的支持；当前会话创建的临时表由显示改为不显示。  4. information_schema.table_constraints视图内CONSTRAINT_NAME字段在主键约束场景由显示约束名改为显示PRIMARY。  5. information_schema.character_sets视图可以查询所有可用字符集信息。  6. information_schema.collations视图可以查询所有可用字符排序规则信息。  7. information_schema.collation_character_set_applicability视图可以查询所有可用排序规则和字符集的对应关系。  8. information_schema.character_sets、information_schema.collations、information_schema.collation_character_set_applicability视图中的CHARACTER_SET_NAME改成小写，查询显示根据字符序细分utf8mb4和utf8。   影响如下语法： 1. 以下事务语法语义改变，改为设置下一个事务特性： 1. set @@transaction_isolation = value  2. set @@transaction_read_only = value  3. set transaction isolation level  4. set transaction {read write \| read only}    2. set transaction 语法语义改变，改为设置会话级事务特性： 1. set \[local\|session\|@@session.\] transaction_isolation = value  2. set \[local\|session\|@@session.\] transaction_read_only = value    3. show transaction_isolation显示为带中划线的隔离级别。  4. 创建生成列不指定STORED和VIRTUAL关键字，默认创建虚拟生成列。  5. SHOW CREATE TABLE语法返回结果集变更，包括： 1. 列/表注释位置变更，从以COMMENT ON语句形式返回改为在CREATE TABLE语句以COMMENT子句形式中返回；  2. 主键与唯一约束位置变更，从以ALTER TABLE ADD CONSTRAINT语句形式返回改为在CREATE TABLE语句以CONSTRAINT子句形式作为表约束中返回；  3. 主键与唯一约束中的USING INDEX TABLESPACE选项不再显示，该选项在设置兼容版本控制开关为s1后被禁用；  4. 索引注释位置变更，从以COMMENT ON语句形式返回改为在CREATE INDEX语句以COMMENT子句形式返回；  5. 全局临时表ON COMMIT选项位置变更，从以CREATE TABLE语句WITH子句中on_commit_delete_rows参数形式返回改为在CREATE TABLE语句以ON COMMIT子句形式返回。    6. SHOW CHARACTER SET语法查询使用视图information_schema.character_sets，查询结果随该视图内容的变化而变化。  7. SHOW COLLATION语法查询使用视图information_schema.collations，查询结果随该视图内容的变化而变化。  8. UPDATE语法中： 1. 如果table_name指定了别名，且只能通过别名引用此表。  2. 仅在单表场景多个字段下，各字段的表达式计算会按从左到右的顺序；如果有引用前面的字段名，则使用其更新后的数据，且支持同一字段名可被修改多次。    9. INSERT ... ON DUPLICATE KEY UPDATE语法中：ON DUPLICATE KEY UPDATE子句更新多列时，如果有引用前面的字段名，则使用其更新后的数据，且支持同一字段名可被修改多次。   影响以下GUC参数： 1. 增加transaction_isolation的参数范围。   影响如下功能： 1. 删除生成列的基列需要先删除对应的生成列。  2. 存储生成列的基列不支持指定SET NULL、SET DEFAULT、CASCADE关键字关联 ON UPDATED和ON DELETE动作。  3. ALTER TABLE修改表涉及存储生成列时，生成列的CHECK约束检查生效。   兼容配置项为s1时的所有行为。 |
| s3          | 影响如下时间数据类型插入表时的隐式转换行为： 1. 控制向TIMESTAMP(n)（n ≤ 5）中插入具有TIMESTAMP(6)精度且超出n指定精度的数据时的行为。  2. 控制向TIME中插入类似"100001101011"的VARCHAR类型的数据，且表示月份部分的数据为00时的行为。  3. 控制NUMERIC类型插入表并隐式转换为DATETIME、TIMESTAMP、DATE类型时的非法数据检验。  4. 控制DATETIME、TIMESTAMP类型插入表并隐式转换为DATE、TIME、INT等类型时的四舍五入进位行为。  5. 控制字符串类型插入表并隐式转换为DATE类型时的四舍五入进位行为。  6. 控制DATE类型转换为JSON类型的行为。  7. 以上具体行为变更请参见[日期时间类型](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0612.html)章节。   影响如下IN操作符行为： 1. 左侧字段类型为字符串，右侧包含DATETIME类型数据和数个非DATETIME类型数据时，结果与IN单列结果保持一致。  2. 左侧字段类型为定点，右侧包含FLOAT类型数据和数个非FLOAT类型数据时，结果与IN单列结果保持一致。  3. 左侧字段类型为FLOAT，右侧包含DOUBLE类型数据时，结果与IN单列结果保持一致。  4. 以上具体行为变更请参见[IN/NOT IN](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0629.html#ZH-CN_TOPIC_0000002793779351__zh-cn_topic_0000001737546702_section1968628161311)。   兼容配置项为s2时的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| s4          | 当配置该选项时： 1. 兼容GUC参数配置为m_format_behavior_compat_options='enable_conflict_funcs, enable_precision_decimal, forbid_none_space_comment, enable_load_data_remote_transmission, disable_zero_chars_conversion, cast_as_new_json, grant_database_nomapping, disable_illegal_function_syntax, enable_convert_charset, enable_update_tuple_count, enable_samename_funcs, enable_uca_collate, between_and_independent_compare, enable_bit_string_logic'的所有行为，具体请参见[m_format_behavior_compat_options]。  2. 兼容GUC参数配置为enable_gpi_auto_update=on的所有行为，具体请参见[enable_gpi_auto_update](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1055.html#ZH-CN_TOPIC_0000002764460596__section19815181515176)。  3. 当带显示宽度的整数类型与定点数类型执行UNION操作时，查询结果正确。   兼容配置项为s3的所有行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
   
**默认值：**""
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**在安装部署后立即设置，后期非必要无需变更。
**设置不当的风险与影响：**影响部分SQL的行为，导致兼容性问题。
#### sql_mode
**参数说明：**B兼容模式下和M-Compatibility模式下SQL行为控制配置项。该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当[sql_compatibility]兼容性参数设置为B、[b_format_version]设置为'5.7'、[b_format_dev_version]设置为's1'时，sql_mode才会生效；或者sql_compatibility兼容性参数设置为M时生效。
- 使用SHOW sql_mode和SELECT @@sql_mode进行查询时，会依据REAL_AS_FLOAT、ANSI_QUOTES、ONLY_FULL_GROUP_BY、NO_UNSIGNED_SUBTRACTION、NO_AUTO_VALUE_ON_ZERO、NO_BACKSLASH_ESCAPES、STRICT_TRANS_TABLES、STRICT_ALL_TABLES、NO_ZERO_IN_DATE、NO_ZERO_DATE、ALLOW_INVALID_DATES、ERROR_FOR_DIVISION_BY_ZERO、TRADITIONAL、NO_AUTO_CREATE_USER、NO_ENGINE_SUBSTITUTION及PAD_CHAR_TO_FULL_LENGTH的顺序，大写显示，不因设置时的顺序与大小写而改变。
- 支持使用数字设置sql_mode。将输入的数字与各选项对应的标志位进行与运算，设置范围：与运算结果为真的各选项。如：
  ```
  SET sql_mode = 33;
  --等价于：
  SET sql_mode= 'real_as_float, only_full_group_by';
  --其中：33 = (32 + 1) = (1<<0 | 1<< 5)
  ```
  
 
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- B模式：空字符串""或"strict_trans_tables,only_full_group_by,no_zero_in_date,no_zero_date,error_for_division_by_zero,no_auto_create_user,no_engine_substitution,pad_char_to_full_length,no_auto_value_on_zero"中的选项值。
- M-Compatibility模式：除支持B模式参数外，还新增了no_unsigned_subtraction、ansi_quotes、allow_invalid_dates、real_as_float、strict_all_tables、traditional。
每个选项值的含义如[表10]所述。
 表10兼容性配置项 
| **兼容性配置项**                | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | B模式参数配置说明                                                                        | M-Compatibility模式参数配置说明 | 使用数字设置时对应的标志位        |
|:---|:---|:---|:---|:---|
| strict_trans_tables         | 设置时，对输入的参数格式和范围做严格校验。无效值输入或者超过范围时，解析报error。 不设置时，对输入的参数格式和范围做宽松校验，无效值输入或者超过范围时，解析报warning，返回对应数据宽松处理后的值。 处理方法： 1、异常数据 字符串插入数值类型时，从第一个非数字开始截断，如'1a'-\>1。 目标类型为时间类型时，返回对应数据的0值。 2、超出最大范围 返回对应数据的最大/最小值。 | 可独立设置和取消。                                                                        | 可独立设置和取消。               | 2097152(1\<\<21)   |
| only_full_group_by       | 不允许出现非GROUP BY的key值、且不是常量和聚集函数的投影列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 可独立设置和取消。                                                                       | 可独立设置和取消。                 | 32(1\<\<5)         |
| no_zero_in_date            | 不允许日期中的年、月、日是0值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 可独立设置和取消，但无实际作用。                                                                 | 可独立设置和取消。                | 8388608(1\<\<23)   |
| no_zero_date                  | 不允许日期是0值（0000-00-00）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 可独立设置和取消，但无实际作用。                                                                 | 可独立设置和取消。               | 16777216(1\<\<24)  |
| error_for_division_by_zero | 不允许被0除。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 可独立设置和取消，但无实际作用。                                                               | 可独立设置和取消。                | 67108864(1\<\<26)     |
| no_auto_create_user       | 无实际作用，仅用作SET SQL_MODE语句包含此选项时不报错的兼容作用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 可独立设置和取消。                                                                       | 可独立设置和取消。                 | 268435456(1\<\<28)    |
| no_engine_substitution     | 无实际作用，仅用作SET SQL_MODE语句包含此选项时不报错的兼容作用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 可独立设置和取消。                                                                      | 可独立设置和取消。                | 1073741824(1\<\<30) |
| pad_char_to_full_length     | 用于表中的char类型列格式化输出，包含时输出带有尾部空格的字符串，否则输出不带尾部空格字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 可独立设置和取消。                                                                     | 可独立设置和取消。                 | 2147483648(1\<\<31)   |
| no_auto_value_on_zero     | 包含此选项后，向AUTO_INCREMENT自动增长列插入0值将不会自增。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 可独立设置和取消。                                                                     | 可独立设置和取消。                | 524288(1\<\<19)      |
| no_unsigned_subtraction     | 禁止无符号数减法，如果使用无符号整数进行减法操作，且结果为负数，则会返回一个错误。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 可独立设置和取消，但无实际作用。                                                                | 可独立设置和取消。                   | 64(1\<\<6)         |
| ansi_quotes                 | 启用ANSI_QUOTES模式，该模式下双引号被视为标识符引用符号，而不是字符串引用符号。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 可独立设置和取消，但无实际作用。双引号总被视为标识符引用符号。                                                 | 可独立设置和取消。                 | 4(1\<\<2)            |
| allow_invalid_dates         | 允许插入无效日期，如果启用该选项，则MySQL将允许插入无效的日期，例如'0000-00-00'。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 可独立设置和取消，但无实际作用。                                                               | 可独立设置和取消。                 | 33554432(1\<\<25)   |
| real_as_float               | 默认将REAL类型视为DOUBLE类型，如果启用该选项，则将REAL类型视为FLOAT类型。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 可独立设置和取消，但无实际作用。                                                                | 可独立设置和取消。                | 1(1\<\<0)             |
| strict_all_tables            | 与strict_trans_tables效果一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 可独立设置和取消。                                                                       | 可独立设置和取消。                 | 4194304(1\<\<22)     |
| traditional                  | 与同时设置strict_trans_tables、strict_all_tables、no_zero_in_date、no_zero_date、error_for_division_by_zero、no_auto_create_user和no_engine_substitution效果一致。                                                                                                                                                                                                                                                                                                                                                                                           | 可独立设置和取消。 说明： 具体是否生效取决于B兼容模式是否支持。 | 可独立设置和取消。                | 134217728(1\<\<27）   |
   
**默认值：**"strict_trans_tables,only_full_group_by,no_zero_in_date,no_zero_date,error_for_division_by_zero,no_auto_create_user,no_engine_substitution"。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### foreign_key_checks
**参数说明：**控制是否开启外键约束的完整性检查。多租场景下，该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
该参数仅在M-Compatibility兼容模式下生效。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示启用外键约束的完整性检查。
- off：表示关闭外键约束的完整性检查。
**默认值：**on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**建议仅在数据导入时，且保证原有数据满足外键约束完整性的场景下，将该参数设置为off，提升导入效率。
**设置不当的风险与影响：**将该参数设置为off时，对参考表、被参考表的DML操作不会触发外键的完整性检查。DML操作后，表中可能存在与外键完整性冲突的数据，且重新启用该参数时，不会对已有数据是否符合外键约束完整性进行校验。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
该参数影响以下行为：
- DDL操作：
  - 在创建表时，无论foreign_key_checks是否启用，都会校验表名是否与已有的外键（被参考表不存在）相匹配，如果匹配，则校验外键定义是否正确，并将被参考表不存在的外键转换为被参考表存在的外键。
  
  - 在添加外键时，如果外键引用的被参考表不存在，foreign_key_checks为on时提示报错信息，foreign_key_checks为off时会创建被参考表不存在的外键。
  
  - 在删除被参考表时，如果指定了CASCADE选项，则无论foreign_key_checks是否启用，都会级联删除参考表上的外键；如果未指定CASCADE选项，foreign_key_checks为on时提示报错信息，foreign_key_checks为off时会将外键转换为参考表不存在的外键。
  
  - 在TRUNCATE被参考表时，如果指定了CASCADE选项，则无论foreign_key_checks是否开启，都会级联删除参考表中的数据；如果未指定CASCADE选项，foreign_key_checks为on时提示报错信息，foreign_key_checks为off时不提示报错信息，也不会级联清除参考表中的数据。
   
- DML操作：具体行为如[表11]所示。
 
 表11foreign_key_checks对DML操作的影响 
|     操作      | foreign_key_checks |               被参考表               |      参考表（被参考表存在）      |   参考表（被参考表不存在）    |
|:------------------------------------------------------------:|:-----------------------------------------------------------------:|:-------------------------------------------------------------------------------:|:--------------------------------------------------------------------:|:---------------------------------------------------------------:|
|     INSERT     |        on         |            无需检查，插入成功。            | 检查完整性，与完整性冲突时，则插入失败。 |   外键字段无法插入非空值。   |
|     INSERT     |        off         |            无需检查，插入成功。             |      跳过检查，插入成功。       |     跳过检查，插入成功。     |
|     DELETE      |        on         |  检查完整性，与完整性冲突时，根据ACTION操作报错或级联修改。  |      无需检查，删除成功。      |    无需检查，删除成功。    |
|     DELETE      |         off         |           跳过检查，删除成功。           |       无需检查，删除成功。        |    无需检查，删除成功。     |
|    UPDATE     |         on         | 检查完整性，与完整性冲突时，根据ACTION操作报错或级联修改。 | 检查完整性，与完整性冲突时，则更新失败。  |  外键字段无法更新为非空值。  |
|    UPDATE     |         off         |             跳过检查，更新成功。             |       跳过检查，更新成功。       |    跳过检查，更新成功。    |
| REPLACE INTO |         on         | 检查完整性，与完整性冲突时，根据ACTION操作报错或级联修改。 | 检查完整性，与完整性冲突时，则操作失败。 | 外键字段无法新增或被更新为非空值。 |
| REPLACE INTO |        off        |            跳过检查，操作成功。             |      跳过检查，操作成功。       |     跳过检查，操作成功。     |
   
 #### auto_increment_increment
**参数说明：**AUTO_INCREMENT自动增长列的自增步长，自增值将由auto_increment_offset + N × auto_increment_increment计算而来，N为正整数。多租场景下，该参数可在PDB级别设置。
**参数类型：**整型
**参数单位：**无
**取值范围：**1 \~ 65535
**默认值：**1。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 根据用户需要设置**。**
**设置不当的风险与影响：** 设置不当会使自增值不符合预期。若参数值小于[auto_increment_offset]，自动增长列自增时会产生错误。
 #### auto_increment_offset
**参数说明：**AUTO_INCREMENT自动增长列的起始值，自增值将由auto_increment_offset + N × auto_increment_increment计算而来，N为正整数。多租场景下，该参数可在PDB级别设置。
**参数类型：**整型
**参数单位：**无
**取值范围：**1 \~ 65535
**默认值：**1。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据用户需要设置。
**设置不当的风险与影响：** 设置不当会使自增值不符合预期。若参数值大于[auto_increment_increment]，自动增长列自增时会产生错误。
#### auto_increment_cache
**参数说明：**对自动增长列批量插入或导入触发自增时，预留自增缓存值的个数。预留自增值时，刷新自增计数器为自增缓存值的最大值，缓存值使用完毕之前，自增计数器值不变，触发自增使用缓存的值。多租场景下，该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 预留的缓存值仅在语句内有效，若预留的自增缓存值没有全部被使用，后续插入语句基于自增计数器触发自增，会出现表中自动增长列的值不连续的情况。
- 并行导入或插入自动增长列触发自增时，每个并行线程预留的缓存值也只在其线程中使用，未完全使用完毕的话，也会出现表中自动增长列的值不连续的情况。
- 对已有数据的表添加自动增长列或修改某列为自动增长列时，已有数据触发自增，预留自增缓存值也受此参数影响。
- 此参数不影响本地临时表中的自动增长列。
- 当sql_compatibility='B'时，本参数仅在b_format_version='5.7'且b_format_dev_version='s2'时生效。
 
**参数类型：**整型
**参数单位：**无
**取值范围：**0 \~ 2147483647
- 参数值为0时，自动预留自增缓存值。
  - 第一次触发自增时，若已知即将插入自动增长列的行数，预留已知数量的值。 例如："INSERT INTO table SELECT ..."和COPY FROM触发自增值无法获取即将插入的行数。ALTER TABLE命令表数据重写时，若触发自增，使用统计信息中的reltuples作为即将预留的行数。 "INSERT INTO table VALUES(...),(...),..."由于要分布到不同DN，在某些执行计划中，DN获取不到即将插入的行数。
    
  
  - 若行数未知，每次预留2\^n个值，例如，第一次自增预留1个值，第二次自增预留2个值，第三次预留4个值，第四次预留8个值，以此类推，若预留值个数超过65535，预留65535个值。
   
- 参数值不为0时，预留缓存值的数量为参数值。
  - 第一次触发自增时，若已知即将插入自动增长列的行数，预留已知数量的值。
  
  - 若行数未知，每次预留auto_increment_cache数量的自增值。
   
**默认值：**0。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值，若默认情况产生自增值不连续的情况，可以根据用户即将批量插入数据量调整参数值。
**设置不当的风险与影响：**参数值越大，批量插入性能越优，也更可能产生不连续的自增值。
#### disable_keyword_options
**参数说明：**数据库兼容性行为配置项，该参数的值由若干个配置项用逗号隔开构成。设置该参数的标识符将不会作为关键字使用。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 不同兼容模式的数据库支持设置的关键字有所差异，具体请参见[表12]。
 表12各兼容模式数据库支持设置disable_keyword_options选项的关键字 
| 关键字                            | A兼容模式数据库 | B兼容模式数据库、C兼容模式数据库、PG兼容模式数据库 | M-Compatibility模式数据库 |
|:---|:---|:---|:---|
| absolute                       | 支持     | 不支持                          | 不支持                    |
| access                        | 支持     | 不支持                          | 支持                     |
| account                       | 支持    | 不支持                         | 不支持                    |
| action                           | 支持       | 不支持                           | 不支持                   |
| active                        | 不支持     | 不支持                            | 支持                     |
| add                             | 支持      | 不支持                           | 不支持                    |
| adddate                         | 不支持    | 支持                             | 不支持                   |
| admin                             | 不支持     | 不支持                           | 支持                     |
| advanced                        | 支持    | 支持                           | 不支持                  |
| algorithm                       | 支持     | 不支持                            | 不支持                  |
| always                         | 支持       | 不支持                           | 不支持                    |
| app                             | 支持     | 不支持                           | 不支持                     |
| append                           | 支持        | 不支持                         | 不支持                    |
| archive                         | 支持       | 不支持                            | 不支持                    |
| array                           | 不支持     | 不支持                           | 支持                      |
| assertion                     | 支持       | 不支持                          | 不支持                      |
| assignment                      | 支持      | 不支持                            | 不支持                    |
| async                            | 支持     | 支持                            | 不支持                  |
| at                              | 支持    | 不支持                            | 不支持                      |
| audit                         | 支持     | 不支持                          | 不支持                   |
| authentication                    | 不支持     | 不支持                           | 支持                    |
| authid                          | 不支持     | 不支持                           | 支持                    |
| auto                            | 支持     | 支持                             | 不支持                     |
| auto_increment                  | 支持     | 支持                            | 不支持                    |
| autoextend                     | 支持      | 不支持                         | 不支持                  |
| autohint                        | 支持     | 支持                            | 支持                    |
| automapped                      | 支持     | 不支持                          | 不支持                     |
| automatic                         | 支持       | 支持                            | 不支持                  |
| backward                       | 支持     | 不支持                          | 不支持                     |
| bad_path                        | 支持      | 不支持                         | 不支持                     |
| barrier                        | 支持     | 不支持                          | 不支持                    |
| before                          | 支持      | 不支持                          | 不支持                  |
| begin_non_anoyblock            | 支持      | 不支持                           | 不支持                   |
| blanks                           | 支持     | 不支持                             | 不支持                    |
| blockchain                     | 支持     | 不支持                            | 不支持                     |
| body                             | 支持       | 不支持                           | 不支持                    |
| buckets                        | 不支持     | 不支持                          | 支持                       |
| bulk                             | 不支持     | 不支持                            | 支持                    |
| byte                          | 支持      | 支持                           | 不支持                   |
| byteawithoutorder                | 支持      | 不支持                         | 不支持                   |
| byteawithoutorderwithequal    | 支持      | 不支持                           | 不支持                    |
| cache                          | 支持      | 不支持                          | 不支持                   |
| called                        | 支持      | 不支持                         | 支持                     |
| cancelable                    | 支持    | 不支持                            | 支持                     |
| catalog                          | 支持      | 不支持                          | 不支持                     |
| chain                         | 支持      | 不支持                            | 不支持                   |
| challenge_response              | 不支持     | 不支持                           | 支持                      |
| change                        | 支持      | 支持                           | 不支持                     |
| characteristics                 | 支持      | 不支持                            | 不支持                    |
| charset                          | 支持     | 支持                           | 不支持                    |
| class                          | 支持      | 不支持                           | 不支持                  |
| clean                           | 支持     | 不支持                          | 不支持                    |
| client                         | 支持        | 不支持                             | 不支持                  |
| client_master_key               | 支持      | 不支持                           | 不支持                    |
| client_master_keys              | 支持      | 不支持                          | 不支持                   |
| clone                           | 不支持      | 不支持                           | 支持                      |
| column_encryption_key           | 支持     | 不支持                          | 不支持                   |
| column_encryption_keys        | 支持    | 不支持                          | 不支持                    |
| columns                         | 支持       | 支持                           | 不支持                     |
| colview                          | 支持       | 支持                            | 不支持                    |
| comment                       | 支持    | 不支持                          | 不支持                     |
| comments                       | 支持     | 不支持                         | 不支持                   |
| compact                       | 支持     | 不支持                          | 支持                    |
| compatible_illegal_chars        | 支持       | 不支持                            | 不支持                     |
| compile                          | 支持       | 支持                           | 不支持                   |
| complete                       | 支持       | 不支持                            | 不支持                    |
| completion                     | 支持        | 支持                            | 不支持                     |
| component                       | 支持       | 支持                            | 不支持                    |
| concurrently                   | 支持        | 不支持                           | 不支持                  |
| condition                        | 支持      | 不支持                          | 不支持                    |
| configuration                   | 支持      | 不支持                             | 不支持                    |
| conflict                         | 不支持   | 不支持                           | 支持                     |
| connection                      | 支持      | 不支持                            | 不支持                    |
| constant                        | 支持      | 不支持                           | 不支持                   |
| containing                     | 支持      | 支持                           | 不支持                    |
| content                        | 支持      | 支持                           | 不支持                    |
| conversion                      | 支持    | 不支持                          | 不支持                   |
| convert                        | 不支持    | 不支持                          | 支持                    |
| coordinator                      | 支持      | 不支持                           | 不支持                    |
| coordinators                  | 支持     | 不支持                             | 不支持                    |
| copy_custom_id                 | 支持       | 不支持                          | 不支持                   |
| cost                            | 支持       | 不支持                          | 不支持                     |
| crossbucket                      | 支持      | 支持                             | 不支持                    |
| csn                             | 支持      | 支持                            | 不支持                      |
| csv                            | 支持      | 不支持                          | 不支持                  |
| cube                          | 支持      | 不支持                            | 不支持                   |
| cume_dist                      | 支持     | 支持                          | 不支持                     |
| current                         | 支持      | 不支持                           | 不支持                   |
| current_schema                 | 支持       | 不支持                          | 不支持                   |
| cycle                          | 支持       | 不支持                            | 不支持                   |
| data                             | 支持      | 不支持                         | 不支持                   |
| datafiles                       | 支持       | 不支持                            | 支持                     |
| datatype_cl                    | 支持       | 不支持                          | 不支持                     |
| date_add                       | 不支持    | 支持                             | 不支持                  |
| date_format                   | 支持      | 不支持                         | 不支持                    |
| date_sub                         | 不支持       | 支持                            | 不支持                     |
| datetime                        | 支持       | 支持                            | 不支持                     |
| day                              | 支持      | 不支持                           | 不支持                   |
| day_hour                        | 支持       | 支持                           | 不支持                     |
| day_microsecond                | 支持     | 支持                          | 不支持                     |
| day_minute                       | 支持      | 支持                             | 不支持                    |
| day_second                      | 支持      | 支持                             | 不支持                   |
| days                           | 支持     | 支持                            | 不支持                     |
| db4aishot                         | 支持      | 支持                             | 不支持                    |
| dbcompatibility                | 支持       | 不支持                           | 不支持                     |
| dbtimezone                      | 支持        | 支持                             | 不支持                   |
| deallocate                      | 支持      | 不支持                            | 不支持                   |
| decode                          | 支持      | 不支持                          | 不支持                     |
| deferred                       | 支持        | 不支持                         | 不支持                    |
| definer                       | 支持     | 不支持                           | 不支持                     |
| definition                    | 支持      | 支持                            | 不支持                    |
| delete_all                     | 支持     | 不支持                           | 支持                     |
| delimiter                        | 支持     | 不支持                         | 不支持                   |
| delimiters                      | 支持      | 不支持                           | 不支持                    |
| delta                           | 支持     | 不支持                            | 不支持                    |
| deltamerge                     | 支持        | 不支持                          | 不支持                     |
| dense_rank                       | 支持      | 支持                           | 不支持                      |
| description                     | 支持      | 支持                             | 支持                     |
| deterministic                  | 支持     | 不支持                           | 不支持                      |
| dictionary                     | 支持      | 不支持                           | 不支持                     |
| direct                          | 支持    | 不支持                           | 不支持                    |
| directory                      | 支持     | 不支持                         | 不支持                    |
| disable_all                     | 支持       | 不支持                             | 支持                     |
| discard                       | 支持     | 不支持                            | 不支持                   |
| discard_path                   | 支持    | 支持                           | 不支持                   |
| disconnect                      | 支持      | 不支持                            | 不支持                    |
| distribute                       | 支持      | 不支持                            | 不支持                   |
| distributed                      | 支持        | 支持                           | 不支持                    |
| distribution                    | 支持    | 不支持                           | 不支持                    |
| document                         | 支持     | 支持                            | 不支持                    |
| dumpfile                         | 支持       | 不支持                          | 支持                    |
| duplicate                      | 支持       | 不支持                          | 不支持                   |
| each                             | 支持    | 不支持                            | 不支持                   |
| elastic                         | 支持      | 不支持                            | 不支持                  |
| empty                          | 支持      | 支持                             | 不支持                  |
| enable_all                       | 支持      | 不支持                            | 支持                      |
| enclosed                       | 支持     | 不支持                           | 不支持                   |
| encoding                        | 支持      | 支持                             | 不支持                   |
| encrypted                       | 支持     | 不支持                           | 不支持                      |
| encrypted_value                 | 支持      | 不支持                           | 不支持                  |
| encryption                       | 支持      | 不支持                          | 不支持                   |
| encryption_type                  | 支持     | 不支持                         | 不支持                    |
| ends                          | 支持      | 不支持                           | 支持                    |
| enforced                         | 支持     | 支持                            | 不支持                     |
| engine                         | 支持      | 不支持                          | 支持                    |
| engine_attribute               | 支持       | 支持                          | 不支持                     |
| entityescaping                 | 支持     | 不支持                            | 支持                    |
| eol                             | 支持      | 不支持                          | 不支持                    |
| errors                          | 支持      | 不支持                           | 不支持                    |
| escaped                         | 支持      | 支持                              | 不支持                     |
| escaping                        | 支持     | 不支持                          | 不支持                   |
| evalname                      | 支持        | 支持                             | 不支持                   |
| event                            | 支持      | 支持                           | 不支持                   |
| events                         | 支持      | 支持                            | 不支持                     |
| every                           | 支持        | 不支持                           | 不支持                     |
| except                           | 支持     | 支持                            | 不支持                    |
| exchange                        | 支持    | 不支持                            | 不支持                   |
| exclude                        | 支持      | 不支持                            | 支持                     |
| excluding                      | 支持     | 不支持                          | 不支持                    |
| exclusive                      | 不支持     | 不支持                           | 支持                    |
| execute                         | 支持    | 不支持                          | 不支持                     |
| expdp                           | 支持       | 不支持                           | 支持                    |
| expire                          | 支持     | 支持                           | 不支持                    |
| expired                       | 支持     | 不支持                          | 不支持                    |
| extend                          | 支持    | 支持                           | 不支持                   |
| external                        | 支持    | 不支持                            | 不支持                    |
| factor                          | 支持       | 支持                           | 不支持                   |
| failed_login_attempts           | 不支持     | 不支持                          | 支持                     |
| family                           | 支持       | 不支持                           | 不支持                     |
| fast                            | 支持     | 不支持                           | 不支持                    |
| features                       | 支持     | 不支持                           | 不支持                    |
| fenced                         | 不支持    | 不支持                          | 支持                    |
| fields                          | 支持     | 不支持                          | 不支持                    |
| fileheader                       | 支持       | 不支持                           | 不支持                    |
| fill_missing_fields            | 支持     | 不支持                            | 不支持                     |
| filler                         | 支持       | 不支持                            | 不支持                    |
| filter                           | 支持     | 不支持                           | 不支持                   |
| finish                          | 支持      | 不支持                           | 支持                      |
| first                          | 支持       | 不支持                            | 不支持                    |
| first_value                   | 支持       | 支持                            | 支持                    |
| fixed                             | 支持       | 不支持                           | 不支持                   |
| following                      | 支持    | 不支持                            | 支持                     |
| force                          | 不支持     | 不支持                            | 支持                      |
| formatter                       | 支持    | 不支持                         | 不支持                    |
| forward                          | 支持      | 不支持                            | 不支持                     |
| freeze                          | 支持      | 不支持                            | 不支持                      |
| functions                      | 支持     | 不支持                           | 不支持                    |
| generate                       | 支持      | 不支持                          | 支持                    |
| generated                       | 支持     | 不支持                           | 不支持                   |
| geomcollection                    | 不支持       | 不支持                          | 支持                     |
| get_format                     | 不支持    | 不支持                          | 支持                      |
| get_master_public_key          | 支持       | 支持                           | 不支持                     |
| get_source_public_key         | 不支持     | 不支持                          | 支持                      |
| granted                         | 支持       | 不支持                            | 不支持                     |
| greatest                       | 支持      | 不支持                           | 不支持                    |
| grouping                       | 支持     | 不支持                            | 支持                     |
| groups                           | 不支持     | 不支持                            | 支持                      |
| gsidead                        | 支持        | 不支持                           | 支持                   |
| gsigetxid                     | 支持    | 支持                            | 不支持                      |
| gsimerge                         | 支持     | 支持                              | 不支持                    |
| gsiready                       | 支持     | 支持                             | 不支持                  |
| gsiswitch                       | 支持       | 支持                           | 不支持                   |
| gsiusable                      | 支持     | 支持                           | 不支持                    |
| gsivalid                         | 支持      | 支持                           | 不支持                    |
| gsiwaitall                      | 支持     | 支持                            | 不支持                   |
| gtid_only                       | 支持      | 支持                           | 不支持                     |
| hdfsdirectory                   | 支持     | 不支持                            | 不支持                  |
| header                         | 支持     | 不支持                          | 不支持                    |
| high                            | 支持    | 不支持                         | 支持                      |
| histogram                      | 支持      | 支持                          | 不支持                     |
| history                         | 不支持     | 不支持                           | 支持                     |
| hold                              | 支持      | 不支持                           | 不支持                    |
| hour                            | 支持     | 不支持                          | 不支持                   |
| hour_microsecond                | 支持      | 不支持                          | 支持                    |
| hour_minute                   | 支持      | 支持                             | 不支持                    |
| hour_second                      | 支持     | 支持                           | 不支持                    |
| hours                         | 支持       | 支持                            | 不支持                     |
| identity                        | 支持     | 不支持                           | 不支持                   |
| ifnull                          | 不支持     | 支持                            | 不支持                   |
| ignore                          | 支持       | 支持                             | 不支持                   |
| ignore_extra_data              | 支持      | 不支持                           | 不支持                  |
| ilm                           | 支持     | 支持                           | 不支持                     |
| ilm_pidx_list                   | 支持      | 支持                            | 不支持                    |
| imcvtable                       | 支持      | 支持                             | 不支持                     |
| immediate                         | 支持       | 不支持                         | 不支持                  |
| immutable                        | 支持       | 不支持                            | 不支持                   |
| impdp                         | 支持       | 支持                            | 不支持                    |
| implicit                        | 支持     | 不支持                           | 不支持                     |
| inactive                         | 支持      | 支持                            | 不支持                   |
| include                       | 支持      | 不支持                           | 不支持                    |
| including                     | 支持      | 不支持                            | 不支持                    |
| increment                     | 支持     | 不支持                             | 不支持                    |
| incremental                    | 支持        | 不支持                           | 不支持                   |
| indexes                           | 支持      | 不支持                            | 不支持                   |
| infile                        | 支持      | 不支持                             | 不支持                    |
| inherit                          | 支持    | 不支持                           | 不支持                   |
| inherits                        | 支持      | 不支持                           | 不支持                     |
| initial                         | 支持      | 不支持                          | 支持                    |
| initiate                       | 不支持     | 不支持                          | 支持                    |
| initrans                        | 支持      | 不支持                           | 不支持                     |
| inline                         | 支持       | 不支持                           | 不支持                  |
| inner                            | 支持       | 不支持                          | 不支持                     |
| inout                          | 支持    | 不支持                            | 不支持                   |
| input                          | 支持    | 不支持                           | 不支持                     |
| insensitive                      | 支持     | 不支持                            | 不支持                   |
| instead                        | 支持       | 不支持                           | 不支持                   |
| internal                       | 支持      | 不支持                         | 不支持                    |
| intersect                        | 不支持   | 不支持                           | 支持                     |
| interval                        | 支持      | 不支持                            | 支持                     |
| invisible                        | 支持     | 支持                             | 不支持                   |
| invoker                        | 支持      | 不支持                             | 不支持                    |
| isnull                           | 支持      | 不支持                           | 不支持                     |
| json_object                    | 不支持     | 支持                          | 支持                    |
| json_table                       | 支持      | 支持                             | 不支持                  |
| json_value                     | 不支持       | 不支持                           | 支持                     |
| keep                             | 支持     | 不支持                           | 支持                     |
| key_path                       | 支持       | 不支持                            | 不支持                    |
| key_store                      | 支持      | 不支持                          | 不支持                   |
| keyring                         | 支持     | 支持                           | 不支持                    |
| kill                          | 支持      | 不支持                           | 不支持                   |
| label                          | 支持    | 不支持                           | 不支持                    |
| lag                             | 不支持    | 不支持                            | 支持                       |
| large                            | 支持       | 不支持                           | 不支持                   |
| last                              | 支持      | 不支持                           | 不支持                     |
| last_day                        | 不支持    | 不支持                            | 支持                      |
| last_value                     | 支持       | 支持                           | 不支持                   |
| lateral                          | 不支持    | 不支持                          | 支持                     |
| lc_collate                     | 不支持     | 不支持                           | 支持                     |
| lead                             | 不支持    | 不支持                            | 支持                      |
| leakproof                       | 支持     | 不支持                          | 支持                     |
| least                            | 支持    | 不支持                             | 不支持                    |
| left                           | 支持      | 不支持                          | 不支持                   |
| lines                          | 支持    | 不支持                            | 支持                     |
| link                              | 支持      | 支持                             | 不支持                    |
| listen                           | 支持        | 不支持                             | 不支持                  |
| lnnvl                           | 支持     | 支持                            | 不支持                  |
| load_bad                        | 支持      | 支持                             | 不支持                    |
| load_discard                    | 支持     | 不支持                           | 支持                    |
| load_integer_len                 | 支持     | 支持                             | 支持                     |
| load_session_id                 | 支持     | 支持                           | 不支持                      |
| load_smallint_len                | 支持       | 支持                             | 不支持                   |
| load_unfixed_len               | 支持      | 支持                            | 不支持                     |
| load_unfixed_start_pos        | 支持       | 支持                           | 不支持                   |
| local                           | 支持       | 不支持                         | 不支持                    |
| location                       | 支持      | 支持                              | 不支持                    |
| locked                           | 支持        | 不支持                            | 支持                     |
| log                           | 不支持   | 不支持                          | 支持                    |
| logging                          | 支持        | 不支持                           | 不支持                   |
| login_any                       | 支持     | 不支持                           | 不支持                     |
| login_failure                    | 支持     | 不支持                            | 不支持                    |
| login_success                   | 支持      | 不支持                            | 不支持                   |
| logout                          | 支持       | 不支持                          | 不支持                   |
| loop                            | 支持       | 不支持                            | 不支持                  |
| low                             | 支持     | 支持                              | 支持                     |
| manual                          | 支持      | 支持                            | 不支持                    |
| mapping                         | 支持       | 不支持                           | 不支持                     |
| mark                           | 支持       | 支持                             | 不支持                    |
| masking                           | 支持      | 不支持                          | 不支持                  |
| master                          | 支持       | 不支持                            | 不支持                     |
| master_compression_algorithms | 支持     | 支持                         | 不支持                    |
| master_public_key_path         | 不支持     | 不支持                            | 支持                     |
| master_tls_ciphersuites        | 不支持  | 不支持                           | 支持                    |
| master_zstd_compression_level  | 不支持    | 不支持                          | 支持                    |
| match                         | 支持    | 不支持                          | 支持                   |
| matched                        | 支持     | 不支持                          | 不支持                    |
| materialized                   | 支持     | 不支持                         | 不支持                  |
| maxextents                     | 支持     | 不支持                         | 不支持                   |
| maxsize                        | 支持      | 不支持                           | 不支持                    |
| maxtrans                        | 支持    | 不支持                         | 不支持                  |
| medium                         | 支持      | 不支持                        | 支持                      |
| mediumint                     | 支持      | 支持                         | 不支持                   |
| member                         | 支持    | 支持                            | 不支持                  |
| microsecond                   | 支持    | 不支持                          | 支持                     |
| minextents                     | 支持      | 不支持                          | 不支持                    |
| minute                         | 支持    | 不支持                         | 不支持                  |
| minute_microsecond             | 支持     | 支持                            | 不支持                    |
| minute_second                  | 支持    | 支持                            | 不支持                  |
| minvalue                        | 支持     | 支持                           | 不支持                   |
| model                           | 支持     | 不支持                        | 不支持                    |
| modification                    | 支持      | 不支持                           | 支持                     |
| month                          | 支持      | 不支持                         | 不支持                   |
| months                        | 支持   | 支持                          | 不支持                     |
| move                            | 支持   | 支持                         | 不支持                    |
| movement                      | 支持    | 不支持                           | 不支持                     |
| names                         | 支持   | 不支持                           | 不支持                   |
| national                        | 支持      | 不支持                           | 不支持                   |
| natural                       | 支持   | 不支持                          | 不支持                 |
| nested                       | 不支持     | 不支持                          | 支持                    |
| next                          | 支持       | 不支持                          | 不支持                  |
| nocache                       | 支持      | 不支持                         | 支持                  |
| nocolview                       | 支持   | 支持                           | 不支持                   |
| nocycle                       | 支持      | 支持                            | 不支持                  |
| node                           | 支持   | 不支持                         | 支持                    |
| noentityescaping                | 支持     | 不支持                          | 支持                   |
| noextend                         | 支持     | 支持                            | 不支持                   |
| nologging                      | 支持     | 不支持                        | 不支持                   |
| nomaxvalue                   | 支持    | 支持                          | 不支持                   |
| nominvalue                       | 支持    | 不支持                          | 支持                   |
| none                           | 支持       | 不支持                           | 不支持                     |
| noscale                         | 支持     | 不支持                          | 支持                      |
| nothing                        | 支持     | 不支持                          | 不支持                   |
| notify                         | 支持      | 不支持                        | 不支持                  |
| notnull                        | 支持     | 不支持                           | 不支持                   |
| now                             | 支持     | 支持                          | 不支持                    |
| nowait                       | 支持     | 支持                           | 不支持                  |
| nth_value                      | 不支持     | 不支持                            | 支持                   |
| ntile                         | 不支持    | 不支持                         | 支持                    |
| nullcols                       | 支持   | 不支持                        | 不支持                   |
| nullif                          | 支持    | 不支持                           | 不支持                   |
| nulls                         | 支持     | 不支持                         | 支持                     |
| numstr                          | 支持    | 不支持                          | 不支持                     |
| nvl                            | 支持     | 不支持                          | 不支持                   |
| nvl2                           | 支持      | 不支持                         | 不支持                  |
| object                         | 支持    | 不支持                          | 不支持                   |
| of                            | 支持     | 支持                          | 支持                    |
| off                          | 不支持     | 不支持                         | 支持                     |
| offline                      | 支持    | 不支持                          | 支持                   |
| oids                            | 支持     | 支持                         | 不支持                   |
| oj                              | 不支持    | 不支持                          | 支持                   |
| old                            | 不支持     | 不支持                          | 支持                   |
| online                         | 支持    | 不支持                          | 支持                    |
| open                            | 支持      | 支持                            | 不支持                   |
| operator                      | 支持    | 支持                           | 不支持                     |
| optimization                  | 支持     | 不支持                         | 不支持                    |
| optional                      | 不支持    | 不支持                           | 支持                    |
| optionally                    | 支持    | 不支持                          | 不支持                   |
| options                      | 支持     | 不支持                         | 不支持                    |
| ordinality                     | 支持      | 不支持                        | 支持                     |
| organization                   | 支持      | 支持                           | 支持                     |
| others                         | 不支持  | 不支持                          | 支持                    |
| out                              | 支持     | 不支持                           | 不支持                 |
| outfile                        | 支持     | 不支持                          | 支持                    |
| over                          | 支持     | 支持                          | 不支持                  |
| overlaps                        | 支持     | 不支持                           | 不支持                   |
| overlay                        | 支持     | 不支持                           | 不支持                    |
| owned                          | 支持     | 不支持                           | 支持                    |
| owner                          | 支持    | 不支持                          | 不支持                   |
| package                        | 支持      | 不支持                         | 不支持                    |
| packages                       | 支持     | 不支持                            | 不支持                   |
| parser                        | 支持     | 不支持                         | 不支持                    |
| partition                     | 支持      | 不支持                           | 不支持                   |
| partitioning                   | 支持    | 不支持                         | 支持                    |
| partitions                    | 支持    | 不支持                        | 不支持                  |
| passing                         | 支持    | 不支持                        | 不支持                     |
| password_lock_time              | 支持      | 支持                           | 不支持                   |
| path                          | 不支持   | 不支持                         | 支持                    |
| per                           | 支持      | 不支持                          | 不支持                   |
| percent                        | 支持     | 不支持                           | 不支持                   |
| percent_rank                   | 不支持    | 不支持                           | 支持                    |
| performance                    | 支持     | 不支持                           | 支持                    |
| perm                             | 支持    | 不支持                         | 不支持                     |
| persist                       | 支持     | 支持                           | 不支持                   |
| persist_only                    | 不支持   | 不支持                          | 支持                  |
| pivot                           | 支持    | 不支持                         | 支持                    |
| plan                           | 支持     | 支持                            | 不支持                   |
| plans                         | 支持     | 不支持                          | 不支持                  |
| pluggable                      | 支持      | 支持                           | 不支持                     |
| policy                         | 支持      | 不支持                           | 不支持                  |
| pool                           | 支持   | 不支持                        | 不支持                    |
| populate                      | 支持     | 支持                            | 支持                    |
| position                       | 支持   | 支持                           | 不支持                  |
| preceding                      | 支持     | 不支持                          | 支持                    |
| predict                       | 支持    | 不支持                          | 不支持                    |
| preferred                       | 支持    | 不支持                          | 不支持                    |
| prefix                          | 支持   | 不支持                        | 不支持                   |
| prepared                       | 不支持   | 不支持                        | 支持                   |
| preserve                      | 支持      | 不支持                          | 不支持                   |
| priority                         | 支持    | 不支持                          | 支持                    |
| private                        | 支持     | 不支持                           | 不支持                   |
| privilege_checks_user         | 支持    | 支持                           | 不支持                   |
| procedural                    | 支持    | 不支持                         | 不支持                  |
| process                        | 不支持   | 不支持                         | 支持                    |
| profile                       | 支持     | 不支持                          | 不支持                   |
| public                        | 支持    | 不支持                          | 支持                   |
| publication                    | 支持      | 不支持                          | 不支持                  |
| publish                        | 支持     | 不支持                          | 不支持                    |
| purge                         | 支持      | 不支持                           | 不支持                 |
| quarter                         | 支持     | 支持                          | 不支持                    |
| query                           | 支持    | 不支持                         | 不支持                     |
| quote                         | 支持     | 不支持                           | 不支持                  |
| random                          | 支持    | 支持                           | 不支持                    |
| randomized                      | 支持     | 不支持                         | 不支持                   |
| range                        | 支持    | 不支持                           | 不支持                     |
| rank                         | 不支持    | 不支持                          | 支持                     |
| ratio                          | 支持    | 不支持                         | 不支持                    |
| reassign                         | 支持   | 不支持                          | 不支持                    |
| rebuild                        | 支持    | 不支持                          | 不支持                    |
| recheck                       | 支持     | 不支持                         | 不支持                  |
| recover                        | 支持     | 不支持                         | 支持                    |
| recursive                      | 支持   | 支持                          | 不支持                   |
| recyclebin                    | 支持      | 不支持                          | 支持                    |
| redisanyvalue                    | 支持       | 不支持                         | 不支持                   |
| ref                            | 支持     | 不支持                          | 不支持                  |
| reference                       | 不支持   | 不支持                          | 支持                    |
| refresh                         | 支持    | 不支持                         | 不支持                   |
| regexp                        | 支持    | 不支持                         | 支持                    |
| regexp_like                    | 支持   | 支持                         | 不支持                    |
| registration                  | 支持    | 支持                            | 不支持                    |
| reindex                         | 支持      | 不支持                           | 支持                     |
| reject                         | 不支持     | 不支持                           | 支持                   |
| relative                        | 支持    | 不支持                            | 支持                    |
| reloptions                     | 支持      | 不支持                           | 不支持                  |
| remote                         | 支持      | 不支持                           | 不支持                    |
| remove                        | 支持     | 不支持                          | 不支持                   |
| repeatable                    | 支持     | 不支持                         | 不支持                     |
| replace                       | 支持     | 不支持                          | 不支持                   |
| replica                        | 支持    | 不支持                            | 支持                   |
| replica_type                    | 支持   | 不支持                          | 不支持                    |
| replicas                      | 不支持    | 不支持                            | 支持                    |
| require_row_format            | 不支持   | 不支持                          | 支持                   |
| resize                       | 支持    | 不支持                          | 不支持                   |
| resource                        | 不支持   | 不支持                         | 支持                    |
| respect                        | 不支持  | 不支持                           | 支持                    |
| restart                       | 支持    | 支持                            | 支持                      |
| retain                        | 不支持    | 不支持                          | 支持                     |
| return                         | 支持     | 不支持                         | 不支持                    |
| returning                     | 不支持   | 不支持                        | 支持                   |
| returns                        | 支持     | 不支持                          | 不支持                  |
| reuse                          | 支持     | 不支持                         | 支持                   |
| right                          | 支持      | 不支持                           | 不支持                    |
| rlike                            | 支持   | 不支持                           | 支持                   |
| role                          | 支持     | 支持                           | 不支持                    |
| roles                          | 支持      | 不支持                        | 不支持                   |
| rollup                       | 支持     | 不支持                            | 不支持                 |
| rotation                        | 支持     | 不支持                          | 支持                      |
| row                            | 支持     | 不支持                         | 不支持                   |
| row_number                     | 不支持   | 不支持                         | 支持                   |
| rows                            | 支持     | 不支持                          | 不支持                   |
| rowtype                         | 支持     | 不支持                         | 不支持                   |
| rule                          | 支持      | 不支持                           | 不支持                    |
| sample                          | 支持   | 不支持                          | 不支持                 |
| scale                           | 支持     | 不支持                          | 支持                    |
| schedule                         | 支持     | 支持                            | 不支持                  |
| scroll                         | 支持      | 支持                          | 不支持                  |
| search                          | 支持       | 不支持                            | 不支持                 |
| second                         | 支持      | 不支持                          | 不支持                   |
| second_microsecond           | 支持      | 不支持                          | 支持                  |
| secondary                      | 支持     | 支持                            | 不支持                  |
| secondary_engine               | 不支持      | 不支持                        | 支持                    |
| secondary_engine_attribute     | 不支持    | 不支持                          | 支持                    |
| secondary_load                 | 不支持    | 不支持                           | 支持                    |
| secondary_unload              | 不支持   | 不支持                         | 支持                   |
| security                      | 支持     | 不支持                        | 不支持                   |
| separator                     | 支持   | 不支持                           | 支持                   |
| sequence                       | 支持     | 支持                          | 不支持                    |
| sequences                        | 支持    | 不支持                           | 不支持                 |
| serializable                  | 支持      | 不支持                          | 不支持                   |
| server                          | 支持    | 不支持                          | 不支持                   |
| sessiontimezone               | 支持     | 不支持                          | 支持                    |
| setof                          | 支持     | 支持                           | 不支持                 |
| sets                           | 支持    | 不支持                            | 不支持                    |
| shippable                     | 支持     | 不支持                           | 支持                    |
| show                            | 支持    | 不支持                         | 不支持                   |
| shrink                           | 支持       | 不支持                           | 支持                     |
| siblings                     | 支持    | 不支持                           | 不支持                   |
| signed                          | 支持      | 支持                           | 不支持                    |
| similar                        | 支持      | 不支持                           | 不支持                   |
| simple                       | 支持     | 不支持                          | 不支持                   |
| size                            | 支持     | 支持                            | 不支持                   |
| skip                          | 支持      | 不支持                         | 支持                    |
| skip_constraint_errors           | 不支持     | 不支持                          | 支持                     |
| slave                           | 支持      | 不支持                          | 支持                    |
| slice                           | 支持      | 支持                          | 不支持                   |
| smalldatetime                  | 支持   | 不支持                           | 支持                   |
| smalldatetime_format            | 支持       | 不支持                         | 支持                     |
| smartroute                    | 支持      | 不支持                          | 不支持                  |
| source                        | 支持     | 不支持                            | 不支持                  |
| source_auto_position          | 不支持    | 支持                           | 支持                   |
| source_bind                    | 不支持    | 不支持                           | 支持                    |
| source_compression_algorithms   | 不支持    | 不支持                         | 支持                      |
| source_connect_retry           | 不支持     | 不支持                          | 支持                     |
| source_delay                   | 不支持    | 不支持                           | 支持                   |
| source_heartbeat_period       | 不支持     | 不支持                          | 支持                   |
| source_host                    | 不支持    | 不支持                          | 支持                   |
| source_log_file                | 不支持     | 不支持                         | 支持                    |
| source_log_pos                 | 不支持    | 不支持                         | 支持                    |
| source_password               | 不支持   | 不支持                         | 支持                    |
| source_port                      | 不支持    | 不支持                        | 支持                     |
| source_public_key_path        | 不支持     | 不支持                          | 支持                   |
| source_retry_count             | 不支持   | 不支持                           | 支持                   |
| source_ssl                    | 不支持     | 不支持                            | 支持                   |
| source_ssl_ca                   | 不支持   | 不支持                          | 支持                      |
| source_ssl_capath               | 不支持    | 不支持                           | 支持                   |
| source_ssl_cert               | 不支持    | 不支持                         | 支持                     |
| source_ssl_cipher             | 不支持     | 不支持                          | 支持                   |
| source_ssl_crl                 | 不支持   | 不支持                           | 支持                    |
| source_ssl_crlpath              | 不支持     | 不支持                         | 支持                    |
| source_ssl_key                | 不支持     | 不支持                         | 支持                     |
| source_ssl_verify_server_cert | 不支持     | 不支持                        | 支持                    |
| source_tls_ciphersuites        | 不支持     | 不支持                           | 支持                      |
| source_tls_version              | 不支持  | 不支持                        | 支持                   |
| source_user                     | 不支持    | 不支持                          | 支持                    |
| source_zstd_compression_level | 不支持    | 不支持                            | 支持                    |
| space                           | 支持    | 不支持                        | 不支持                   |
| specification                  | 支持    | 不支持                        | 支持                   |
| spill                          | 支持      | 不支持                          | 不支持                    |
| split                           | 支持     | 支持                         | 不支持                  |
| srid                         | 不支持   | 不支持                          | 支持                    |
| stable                          | 支持    | 不支持                         | 支持                      |
| standalone                      | 支持     | 不支持                         | 不支持                  |
| starting                       | 支持   | 不支持                          | 支持                      |
| starts                        | 支持     | 支持                          | 不支持                    |
| statement                      | 支持     | 不支持                          | 不支持                    |
| statement_id                 | 支持    | 不支持                           | 不支持                    |
| statistics                    | 支持     | 不支持                         | 不支持                   |
| stdin                           | 支持   | 支持                          | 不支持                  |
| stdout                       | 支持      | 不支持                         | 支持                  |
| storage                          | 支持    | 不支持                          | 不支持                   |
| store                         | 支持    | 不支持                          | 不支持                   |
| stored                         | 支持       | 不支持                        | 不支持                    |
| str                              | 支持        | 支持                              | 不支持                    |
| stratify                        | 支持    | 不支持                        | 不支持                  |
| stream                          | 不支持      | 不支持                          | 支持                   |
| strict                        | 支持     | 不支持                          | 支持                    |
| strip                         | 支持     | 不支持                           | 不支持                    |
| subdate                          | 不支持     | 不支持                         | 支持                    |
| subpartition                  | 支持     | 不支持                            | 不支持                  |
| subpartitioning                 | 支持      | 支持                             | 不支持                  |
| subpartitions                  | 支持     | 支持                          | 不支持                  |
| subscription                  | 支持   | 不支持                          | 不支持                  |
| substr                          | 支持    | 支持                           | 不支持                    |
| substring                      | 支持     | 支持                           | 不支持                  |
| sys_refcursor                  | 支持      | 不支持                         | 不支持                  |
| sysdate                        | 不支持     | 不支持                          | 支持                    |
| sysid                        | 支持      | 不支持                           | 不支持                    |
| system                         | 不支持    | 不支持                          | 支持                  |
| table_compress_clause          | 支持    | 不支持                          | 支持                    |
| tables                         | 支持     | 不支持                          | 不支持                  |
| tablesample                     | 支持     | 不支持                           | 不支持                    |
| tablespace                     | 支持     | 不支持                         | 不支持                 |
| target                       | 支持     | 不支持                           | 不支持                  |
| temp                          | 支持      | 不支持                          | 不支持                    |
| template                      | 支持    | 不支持                         | 不支持                    |
| temporary                      | 支持   | 不支持                         | 不支持                   |
| terminated                     | 支持     | 不支持                           | 不支持                  |
| than                            | 支持       | 不支持                          | 不支持                 |
| thread_priority               | 支持    | 支持                          | 不支持                    |
| ties                          | 不支持   | 不支持                           | 支持                   |
| time_format                   | 支持     | 不支持                          | 不支持                  |
| timecapsule                   | 支持     | 不支持                          | 不支持                    |
| timestamp_format               | 支持     | 不支持                          | 不支持                  |
| timestampadd                     | 不支持    | 不支持                        | 支持                    |
| timestampdiff                  | 支持     | 不支持                          | 不支持                   |
| tls                            | 支持     | 支持                          | 不支持                    |
| transform                      | 支持   | 不支持                          | 不支持                  |
| treat                          | 支持      | 不支持                          | 不支持                   |
| trim                            | 支持   | 不支持                           | 支持                    |
| trusted                          | 支持   | 不支持                         | 不支持                 |
| tsfield                         | 支持    | 不支持                         | 不支持                   |
| tstag                            | 支持     | 不支持                         | 不支持                 |
| tstime                       | 支持    | 不支持                         | 不支持                   |
| turbo                          | 支持     | 不支持                          | 支持                    |
| types                         | 支持     | 不支持                         | 不支持                    |
| unbounded                     | 支持     | 支持                            | 不支持                  |
| uncommitted                   | 支持       | 不支持                            | 不支持                    |
| unencrypted                    | 支持    | 不支持                         | 不支持                  |
| unit                          | 支持    | 不支持                           | 支持                    |
| unknown                      | 支持      | 不支持                          | 不支持                  |
| unlimited                    | 支持      | 不支持                          | 不支持                   |
| unlisten                        | 支持      | 不支持                          | 不支持                  |
| unlock                       | 支持     | 不支持                         | 不支持                   |
| unlogged                      | 支持    | 不支持                           | 不支持                  |
| unpivot                       | 支持       | 支持                         | 不支持                   |
| unregister                     | 支持    | 支持                         | 不支持                    |
| unsigned                      | 支持      | 不支持                           | 支持                    |
| until                         | 支持       | 不支持                         | 不支持                  |
| unusable                      | 支持     | 支持                          | 不支持                   |
| url                            | 不支持     | 不支持                          | 支持                     |
| useeof                        | 支持   | 不支持                          | 不支持                   |
| vacuum                       | 不支持   | 不支持                          | 支持                    |
| valid                          | 支持      | 不支持                          | 支持                   |
| validate                      | 支持     | 不支持                          | 不支持                   |
| validation                     | 支持     | 不支持                            | 不支持                     |
| validator                       | 支持     | 不支持                         | 不支持                   |
| varchar2                      | 不支持  | 不支持                          | 支持                      |
| variables                       | 支持     | 不支持                         | 不支持                   |
| varying                       | 支持     | 不支持                         | 不支持                   |
| vcgroup                       | 支持    | 不支持                          | 不支持                   |
| vcpu                             | 不支持   | 不支持                         | 支持                    |
| verbose                          | 支持    | 不支持                         | 支持                   |
| verify                         | 支持     | 不支持                           | 支持                    |
| version                          | 支持      | 支持                           | 不支持                  |
| visible                        | 支持     | 不支持                          | 支持                     |
| volatile                      | 支持     | 支持                            | 支持                    |
| wait                           | 支持    | 不支持                          | 不支持                   |
| weak                            | 支持     | 不支持                           | 不支持                    |
| week                          | 支持     | 不支持                         | 支持                    |
| wellformed                     | 支持       | 支持                          | 不支持                   |
| whitespace                      | 支持     | 不支持                           | 不支持                 |
| window                         | 支持      | 支持                          | 不支持                  |
| within                         | 支持    | 不支持                         | 支持                     |
| without                         | 支持    | 不支持                          | 不支持                   |
| workload                       | 支持     | 不支持                         | 不支持                  |
| wrapper                         | 支持    | 不支持                           | 不支持                   |
| xmlattributes                | 支持      | 不支持                          | 不支持                  |
| xmlcast                        | 支持       | 支持                           | 不支持                  |
| xmlconcat                        | 支持     | 不支持                        | 不支持                     |
| xmlelement                     | 支持       | 不支持                          | 不支持                   |
| xmlexists                     | 支持      | 不支持                         | 不支持                   |
| xmlforest                      | 支持    | 不支持                          | 不支持                    |
| xmlnamespaces                    | 支持      | 不支持                        | 不支持                   |
| xmlparse                       | 支持       | 不支持                            | 不支持                  |
| xmlpi                          | 支持    | 支持                            | 不支持                  |
| xmlquery                        | 支持     | 支持                           | 不支持                     |
| xmlroot                        | 支持    | 不支持                          | 不支持                   |
| xmlserialize                 | 支持    | 不支持                        | 不支持                     |
| xmltable                      | 支持     | 不支持                        | 支持                   |
| xmltype                         | 支持      | 支持                           | 不支持                    |
| year_month                   | 支持   | 支持                          | 支持                    |
| years                         | 支持     | 支持                           | 不支持                 |
| zerofill                        | 支持       | 支持                           | 不支持                    |
| zone                           | 支持      | 支持                             | 不支持                  |
   
**默认值：**
- 非M-Compatibility模式数据库下："datetime,regexp,rlike,zerofill"。
- M-Compatibility模式数据库下：""。
- 在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**该参数打开后，作为关键字使用的部分功能会失效，请谨慎使用。如果要屏蔽的关键字在当前兼容模式数据库的待屏蔽关键字数组里不存在，其他兼容模式数据库里存在时，则产生WARNING；如果其他兼容模式数据库里也不存在，则产生ERROR。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
B兼容模式下，datetime、regexp、rlike、zerofill是否作为保留关键字由系统确定，用户无法修改和删除。具体情况为：初始状态下系统会将datetime、regexp、rlike、zerofill添加到参数disable_keyword_options中，此时datetime、regexp、rlike、zerofill不作为保留关键字；设置set b_format_version = '5.7'和set b_format_dev_version = 's1';（或者高于s1的版本）后，系统会将datetime、regexp、rlike、zerofill从参数disable_keyword_options中删除，此时可作为保留关键字使用。
#### disable_plsql_keyword_options
**参数说明：**用于将设置的标识符当作非关键字使用。数据库兼容性行为配置项，该参数的值由若干个配置项用逗号隔开构成。多租场景下，该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：**支持的配置项包括PIPE、PIPELINED、RANGE、REPLACE、SUBTYPE。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 该参数打开后，作为关键字使用的部分功能会失效，请谨慎使用。
- 如需取消屏蔽plsql关键字功能，请将该参数设置为空值。
 
#### td_compatible_truncation
**参数说明：**控制是否开启与TD数据库相应兼容的特征。在用户连接上与TD兼容的数据库时，可以将参数设置成为on（即超长字符串自动截断功能启用），该功能启用后，在后续的insert语句中，对目标表中char和varchar类型的列插入超长字符串时，会按照目标表中相应列定义的最大长度对超长字符串进行自动截断。保证数据都能插入目标表中，而不是报错。该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 超长字符串自动截断功能不适用于insert语句包含外表的场景。
- 如果向字符集为字节类型编码（SQL_ASCII、LATIN1等）的数据库中插入多字节字符数据（如汉字等），且字符数据跨越截断位置，这种情况下，按照字节长度自动截断，自动截断后会在尾部产生非预期结果。如果用户有对于截断结果正确性的要求，建议用户采用UTF8等能够按照字符截断的输入字符集作为数据库的编码集。
 
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示打开超长字符串自动截断功能。
- off：表示关闭超长字符串自动截断功能。
**默认值：**off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### uppercase_attribute_name
**参数说明**：设置列名以大写形式返回给客户端。该参数仅限于A兼容模式下使用。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示列名以大写形式返回给客户端。
- off：表示列名不以大写形式返回给客户端。
**默认值**：off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 不允许通过gs_guc set、gs_guc reload、修改gaussdb.conf、alter database set、alter user set进行全局化修改本参数。
- 当开启该参数且对投影列指定了带引号的别名时，是否以大写形式返回列名还会受[uppercase_attribute_name_respect_quote]参数的控制。
- 当开启该参数后，仅当列名为全小写时，会将其转为全大写返回给客户端。当列名为大小写混用时，不会对列名转大写。
  ```
  gaussdb=# SET uppercase_attribute_name=off;
  SET
  gaussdb=# SELECT 1 AS ab, 2 AS Ab, 3 AS AB, 4 AS "ab", 5 AS "Ab", 6 AS "AB";
   ab | ab | ab | ab | Ab | AB 
  ----+----+----+----+----+----
    1 |  2 |  3 |  4 |  5 |  6
  (1 row)
  gaussdb=# SET uppercase_attribute_name=on;
  SET
  gaussdb=# SELECT 1 AS ab, 2 AS Ab, 3 AS AB, 4 AS "ab", 5 AS "Ab", 6 AS "AB";
   AB | AB | AB | AB | Ab | AB 
  ----+----+----+----+----+----
    1 |  2 |  3 |  4 |  5 |  6
  (1 row)
  ```
  
 
 #### uppercase_attribute_name_respect_quote
**参数说明**：开启uppercase_attribute_name参数后，控制带引号的列别名，是否保留原始大小写形式返回客户端。该参数仅限于A兼容模式下使用。该参数可在PDB级别设置。
**参数类型：**枚举类型
**参数单位：**无
**取值范围：**
- off：带引号且全小写的列别名转为大写返回，带引号且全大写或大小写混用的列别名保留原始大小写返回。
- select_alias：对于最外层为SELECT查询且投影列指定了带引号别名的场景，保留原始大小写返回；其余场景行为与off一致。
**默认值**：off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当从不支持该参数的版本升级到当前版本时，升级未提交情况下设置该参数不生效。
- 不允许通过gs_guc set、gs_guc reload、修改gaussdb.conf、alter database set、alter user set进行全局化修改本参数。
- 该参数仅当开启uppercase_attribute_name参数后才生效，当设置该参数为select_alias后，仅影响SELECT查询语句，不影响PBE、CREATE VIEW、DECLARE CURSOR等场景。
  ```
  gaussdb=# SET uppercase_attribute_name=on;
  SET
  gaussdb=# SET uppercase_attribute_name_respect_quote=off;
  SET
  gaussdb=# SELECT 1 AS "a";
   A 
  ---
   1
  (1 row)
  gaussdb=# SET uppercase_attribute_name_respect_quote=select_alias;
  SET
  gaussdb=# SELECT 1 AS "a";
   a 
  ---
   1
  (1 row)
  gaussdb=# PREPARE p1 AS SELECT 1 AS "a";
  PREPARE
  gaussdb=# EXECUTE p1;
   A 
  ---
   1
  (1 row)
  gaussdb=# CREATE VIEW v1 AS SELECT 1 AS "a";
  CREATE VIEW
  gaussdb=# SELECT * FROM v1;
   A 
  ---
   1
  (1 row)
  gaussdb=# CREATE OR REPLACE PROCEDURE p_test_quote(rc INOUT REFCURSOR) AS
  gaussdb$# BEGIN
  gaussdb$#     OPEN rc FOR SELECT 1 AS "ab";
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# BEGIN;
  BEGIN
  gaussdb=# CALL p_test_quote('rc');
   RC 
  ----
   rc
  (1 row)
  gaussdb=# FETCH ALL FROM rc;
   AB 
  ----
    1
  (1 row)
  gaussdb=# COMMIT;
  COMMIT
  gaussdb=# DECLARE c CURSOR FOR SELECT 1 AS "ab", 2 AS "cd";
  DECLARE CURSOR
  gaussdb=# FETCH 1 FROM c;
   AB | CD 
  ----+----
    1 |  2
  (1 row)
  gaussdb=# CLOSE c;
  CLOSE CURSOR
  gaussdb=# COMMIT;
  COMMIT
  ```
  
 
#### enable_copy_error_log
**参数说明**：控制gs_loader使用错误表pg_catalog.gs_copy_error_log以及日志表pg_catalog.gs_copy_summary_log的开启和关闭。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启错误表和日志表。
- off：表示关闭错误表和日志表。
**默认值**：off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### loader_support_nul_character
**参数说明：**数据库平台迭代小版本兼容性行为配置项。该参数可在PDB级别设置。
**参数类型**：字符串
**参数单位：**无
**取值范围：** ""、"s1"、"s2"，具体含义见[表13]。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 使用gs_loader导入工具开启nul字符(0x00)容错特性时，涉及到此GUC参数的设置。
- 具体请参见[gs_loader导入数据](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0939.html)。
 
 表13兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                  |
|:---|:---|
| s1           | 设置gs_loader在导入过程中数据文件存在nul字符处理方式。当数据文件中存在nul字符时，会根据nul字符的位置对数据进行截断，nul字符前的数据会被导入到表中，nul字符后的数据会被截断丢弃，用作功能的前向兼容。 |
| s2           | 设置gs_loader在导入过程中数据文件存在nul字符处理方式。当数据文件中存在nul字符时，会先将nul字符转换成为空格字符" "(0x20)，再进行加工，判断和导入。                          |
| 空值           | 参数默认配置，不影响任何功能使用。                                                                                            |
   
 #### a_format_copy_version
**参数说明：**数据库平台迭代小版本兼容性行为配置项，该参数的值为字符串枚举值。使用gs_loader导入工具新特性时，需要设置对应的值。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表14]。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 兼容性配置项时设置字符串，具体请参见[gs_loader导入数据](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0939.html)，使用方式为通过guc_param设置a_format_copy_version参数。
- 在参数a_format_version值为10c和a_format_dev_version值为s7的情况下，支持部分兼容性配置项的行为，具体请参见[a_format_dev_version]和[a_format_version]。
 
 表14兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
|:---|:---|
| s1        | - 支持gs_loader指定数据类型（CHAR\[(length)\]/INTEGER external\[(length)\]/FLOAT external\[(length)\]/DECIMAL external\[(length)\]/TIMESTAMP/DATE/DATE EXTERNAL/INTEGER/SMALLINT/RAW\[(length)\]）导入数据。  - 支持gs_loader列表达式使用场景扩展。针对原数据不满足列的约束，但经过transform表达式转换后符合列约束的场景，不开启该参数时导入失败，开启该参数后可成功导入数据库。场景举例：表的列限制长度为10，原数据长度为100，但transform表达式为取其中长度为10的子串。  - gs_loader导入数据的CSV模式下，会跳过字段开头空格。并且当某个字段第一个非空格字符不是enclosed字符时，忽略enclosed设置。当未匹配到关闭enclosed字符，先匹配到行末时，会进行报错。   |
   
#### enable_volatile_match_index
**参数说明**：控制volatile类型函数是否可以匹配索引，仅在DBCOMPATIBILITY为A的数据库中生效。volatile函数匹配索引存在语义风险，stable、immutable函数默认可以匹配索引，且符合语义。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启。
- off：表示关闭。
**默认值**：off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于SUSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据函数实际易变性进行设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_union_all_order
**参数说明**：控制UNION ALL在主查询未排序的情况下，是否支持子查询保序。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启。
- off：表示关闭。
**默认值**：
- on：新安装的数据库的默认值。
- off：该参数自503.2版本添加，503.2版本之前的数据库升级后此参数为off。升级前若存在该参数并且设置了值，升级后默认值不变。
- 在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_immutable_optimization
**参数说明**：控制immutable类型函数是否可以被优化执行，仅在DBCOMPATIBILITY为A的数据库中生效。如果带有immutable定义的函数违反immutable语义，则其调用结果、其值以及对其调用者的影响均未定义。该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启。
- off：表示关闭。
**默认值**：on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_object_special_character
**参数说明**：控制执行CREATE EXTENSION语句时，若脚本文件中使用"@extschema@"，此时control文件中schema参数的值是否可以包含\["$'\\\]中任意特殊字符。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启，可以包含\["$'\\\]中任意特殊字符。
- off：表示关闭，不可以包含\["$'\\\]中任意特殊字符。
**默认值**：
- off：新安装的数据库的默认值。
- on：该参数自505.0版本添加，505.0版本之前的数据库升级后此参数为on。升级前若存在该参数并且设置了值，升级后默认值不变。
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**扩展功能为内部使用功能，只允许操作数据库内部的高级包或扩展。
**设置不当的风险与影响：**修改该参数取值可能导致数据库出现意料之外的结果，请保持默认值。
#### enable_implicit_cast_str2num
**参数说明**：在整型数据类型与字符串数据类型进行比较操作符或者算术运算操作符运算时，控制字符串是否能够转换为NUMERIC。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
仅在a_format_version='10c'，a_format_dev_version='s1'时生效。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启。 比较操作符（\>、\>=、\<、\<=、=、\<\>）：字符串数据类型会被隐式转换成NUMERIC类型（在未开启[behavior_compat_options]参数的enable_crosstype_integer_operator选项时，整型数据类型也会被隐式转换成NUMERIC类型）。
  算术操作符（+、-、\*、/、%、\^）：整型数据类型和字符串数据类型都会被隐式转换成NUMERIC类型。
  
- off：表示关闭。字符串数据类型会被隐式转换成整型数据类型。
**默认值**：on
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### a_format_disable_func
**参数说明**：禁用指定的系统函数。该参数的值由若干个系统函数OID值用逗号隔开组成。设置该参数的系统函数将不能被调用。当某一系统函数不能满足用户需求并且需要使用相同函数名的自定义函数时，可使用该功能。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：**字符串，由若干个系统函数OID值用逗号隔开组成。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于SUSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### enable_convert_illegal_char
**参数说明** **：**对输出结果中的非法编码是否不进行校验并以占位符替换显示。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启，特殊字符在查询时将替换为[convert_illegal_char_mode](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1049.html#ZH-CN_TOPIC_0000002793779013__section1195344211239)参数指定符号的编码。
- off：表示关闭，查询结果中包含的超出当前字符集编码规则外的编码时会在校验后报错。
**默认值** **：**off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式** **：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议** **：**推荐使用默认值，仅在数据中存在特殊字符且需要对特殊字符进行强制不报错处理时开启该参数。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
1. 当数据库字符集为utf8、zhs16gbk、gb18030、gb18030-2022、latin1，enable_convert_illegal_char=on时生效，且当数据库客户端与服务端字符集不相同时，非法编码将以占位符形式显示。
2. 特殊字符范围：本文所指的特殊字符范围仅包括完全异常编码和混合编码，不支持\\u0000字符。若字符编码中包含\\u0000字符，在使用时通常会在\\u0000处截断，无法保证数据的完整性。
3. 在PBE场景下，当数据库客户端与服务端字符集相同时，绑定参数无需编码转换，但仍需校验合法性，并在校验时对绑定参数中的非法字符进行处理。当关闭enable_convert_illegal_char参数时，将绑定参数中的非法字符（不包含\\u0000）替换成占位符（[convert_illegal_char_mode](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1049.html#ZH-CN_TOPIC_0000002793779013__section1195344211239)参数指定的字符）。当开启enable_convert_illegal_char参数时，保留原字符。
4. 在数据库客户端与服务端字符集不相同时，超出当前服务端字符集外的特殊字符只能通过函数dbe_raw.cast_to_varchar2()写入或导入导出工具写入数据库。
5. 仅支持客户端字符集与服务端字符集之间的编码处理，非客户端字符集与服务端字符集之间的编码校验与关闭参数时行为一致。
6. 当开启GUC参数时，特殊字符在下表所列的函数、高级包函数中的表现为：
   - 在客户端与服务端字符集一致时，特殊字符在查询时不报错，与开启GUC参数前的行为保持一致。
   
   - 在客户端与服务端字符集不一致时，特殊字符在查询时显示为占位符（默认为?）。
   
   - 不建议客户使用函数处理包含特殊字符的字符串，下表所列函数处理包含特殊字符的字符串不会产生报错，但无法保证结果的正确性。
    
 
表15特殊字符支持的函数及高级包函数 
| 序号    | 函数名/高级包函数名                                                                                                                                                                                                                          |
|:---|:---|
| 1    | bit_length(string)                                                                                                                                                                                                                   |
| 2   | btrim(string text \[, characters text\])                                                                                                                                                                                            |
| 3     | char_length(string) character_length(string)                                                                                                                                       |
| 4  | chr(cvalue int\|bigint) chr(integer)                                                                                                                                                 |
| 5   | concat(str1,str2)                                                                                                                                                                                                                  |
| 6    | concat_ws(sep text, str"any" \[, str"any" \[, ...\] \])                                                                                                                                                                            |
| 7   | decode(string text, format text)                                                                                                                                                                                                     |
| 8     | dump(expr\[, return_fmt \[, start_position \[, length \] \] \])                                                                                                                                                                    |
| 9   | encode(data bytea, format text)                                                                                                                                                                                                    |
| 10 | find_in_set(text, set)                                                                                                                                                                                                               |
| 11   | format(formatstr text \[, str"any" \[, ...\] \])                                                                                                                                                                                   |
| 12   | left(str text, n int)                                                                                                                                                                                                                 |
| 13    | length(string)                                                                                                                                                                                                                      |
| 14   | lengthb(text/bpchar)                                                                                                                                                                                                                |
| 15 | ltrim(string \[, characters\])                                                                                                                                                                                                      |
| 16  | md5(string)                                                                                                                                                                                                                       |
| 17  | notlike(x bytea name text, y bytea text)                                                                                                                                                                                            |
| 18  | octet_length(string)                                                                                                                                                                                                                 |
| 19   | overlay(string placing string FROM int \[for int\])                                                                                                                                                                                 |
| 20   | quote_ident(string text)                                                                                                                                                                                                           |
| 21   | quote_literal(string text)                                                                                                                                                                                                        |
| 22   | quote_nullable(string text)                                                                                                                                                                                                          |
| 23    | rawcat(raw,raw)                                                                                                                                                                                                                    |
| 24   | regexp_count(string text, pattern text \[, position int \[, flags text\]\])                                                                                                                                                         |
| 25    | regexp_instr(string text, pattern text \[, position int \[, occurrence int \[, return_opt int \[, flags text\]\]\]\])                                                                                                               |
| 26  | regexp_like(source_string, pattern \[, match_parameter\]) regexp_like(text,text,text)                                                                                                 |
| 27    | regexp_matches(string text, pattern text \[, flags text\])                                                                                                                                                                          |
| 28   | regexp_replace(string, pattern, replacement \[,flags \]) regexp_replace(string text, pattern text \[, replacement text \[, position int \[, occurrence int \[, flags text\]\]\]\]) |
| 29  | regexp_split_to_array(string text, pattern text \[, flags text \])                                                                                                                                                                 |
| 30  | regexp_split_to_table(string text, pattern text \[, flags text\])                                                                                                                                                                   |
| 31   | regexp_substr(source_char, pattern) regexp_substr(string text, pattern text \[, position int \[, occurrence int \[, flags text\]\]\])                                               |
| 32  | repeat(string text, number int )                                                                                                                                                                                                   |
| 33   | replace(string text, from text, to text)                                                                                                                                                                                          |
| 34    | replace(string, substring)                                                                                                                                                                                                          |
| 35    | reverse(str)                                                                                                                                                                                                                       |
| 36    | right(str text, n int)                                                                                                                                                                                                                |
| 37    | rtrim(string \[, characters\])                                                                                                                                                                                                       |
| 38     | sha(string)                                                                                                                                                                                                                        |
| 39    | sha1(string)                                                                                                                                                                                                                       |
| 40   | sha2(string, hash_length)                                                                                                                                                                                                            |
| 41      | split_part(string text, delimiter text, field int)                                                                                                                                                                                  |
| 42   | substring(string \[from int\] \[for int\]) substring(string from pattern for escape) substring(string from pattern)                |
| 43     | substring_inner(string \[from int\] \[for int\])                                                                                                                                                                                     |
| 44   | tconvert(key text, value text)                                                                                                                                                                                                      |
| 45    | to_single_byte(char)                                                                                                                                                                                                                 |
| 46     | translate(string text, from text, to text)                                                                                                                                                                                          |
| 47  | trim(\[leading \|trailing \|both\] \[characters\] from string)                                                                                                                                                                       |
| 48    | unistr(string)                                                                                                                                                                                                                    |
| 49   | vsize(expr)                                                                                                                                                                                                                          |
| 50  | PKG_UTIL.RAW_CAST_FROM_VARCHAR2                                                                                                                                                                                                       |
| 51     | PKG_UTIL.LOB_CONVERTTOCLOB                                                                                                                                                                                                         |
| 52   | PKG_UTIL.LOB_RAWTOTEXT                                                                                                                                                                                                              |
| 53     | PKG_UTIL.LOB_TEXTTORAW                                                                                                                                                                                                            |
| 54   | PKG_UTIL.RAW_CAST_TO_VARCHAR2                                                                                                                                                                                                      |
| 55   | DBE_OUTPUT.PUT                                                                                                                                                                                                                       |
| 56     | DBE_OUTPUT.PUT_LINE                                                                                                                                                                                                                 |
   
#### fix_func_selection
**参数说明** **：**控制是否优化函数匹配策略。多租场景下，该参数可在PDB级别设置。
catlist顺序问题：若用户自定义函数与系统函数存在冲突，数据库系统在选择函数时，会受该系统函数在数据库系统中的注册顺序影响，从而导致选择函数结果不同。
**参数类型：**字符串
**参数单位：**无
**取值范围：**""、"catlist"。
- ""：不进行优化，与505.1.0版本之前的版本保持一致。
- "catlist"：优化catlist顺序问题，始终优先选择系统函数并执行。
**默认值：**
- "catlist"：新安装的数据库的默认值。
- ""：505.1.0版本之前的数据库升级后的默认值。
- 在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### enable_force_create_obj
**参数说明**：用于控制一次性入库功能的开启与关闭。开启该参数后，若创建或重建函数、包时存在未定义的对象，会创建一个虚拟的对象用于编译，并在函数体编译的过程中通过try catch捕获异常，使创建或重建过程能够运行成功；创建视图时，如果视图依赖的对象不存在或缺少查询权限，该视图仍能够创建成功。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围**：
- on：打开一次性入库功能。
- off：关闭一次性入库功能。
**默认值：**off。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据需求场景进行配置。若无特殊情况，建议开启对应功能。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### ddl_invalid_mode
**参数说明：**用于控制在对函数或包做DROP操作时，对依赖其的对象（函数或包）进行的行为。多租场景下，该参数可在PDB级别设置。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
级联失效依赖对象的过程中，当出现了已失效的对象时，中断级联失效操作。
**参数类型：**枚举类型
**参数单位：**无
**取值范围：**
- delete：对函数或包做DROP操作时，级联删除依赖其的对象（函数或包）。
- invalid：对函数或包做DROP操作时，级联失效依赖其的对象（函数或包）。
**默认值：**delete。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据需求场景进行配置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_view_invalidation
**参数说明：**用于控制视图失效功能的开启与关闭。开启该参数后，若视图依赖对象发生变更，则视图失效。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围**：
- on：打开视图失效功能。
- off：关闭视图失效功能。
**默认值：**off
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
视图失效重编译请参见《开发指南》中"特性使用指导 \> 失效重编译"章节。
#### enable_proc_exec_check
**参数说明：**用于控制存储过程执行时，对依赖对象有效性进行检查。参数打开后，若依赖对象已经被失效，则不会继续执行当前存储过程，返回报错。
**参数类型：**布尔型
**参数单位：**无
**取值范围**：
- on：设置为on时，会在存储过程执行时进行有效性检查。
- off：设置为off时，不会在存储过程执行时进行有效性检查。
**默认值：**on
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据需求场景进行配置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
若从507.0版本之前升级至507.0及之后版本，该参数会默认设置为off。若新安装版本为507.0及之后版本，该参数默认设置为on。
#### max_allowed_packet
**参数说明：**M-Compatibility模式数据库行为配置项，用于表示字符串函数返回值上限。若实际结果超过该上限，则会告警，并返回NULL值。
**参数类型：**整型
**参数单位：**字节
**取值范围：**1024 \~ 1073741824（取值只能是1024的倍数，非倍数时将向下舍入到最接近的倍数）。
**默认值：**4194304
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### div_precision_increment
**参数说明：**M-Compatibility模式数据库行为配置项。用于设置除法结果精度提升值，即除法运算结果的小数位数等于被除数的小数位数加上该参数值。多租场景下，该参数可在PDB级别设置。
**参数类型：**整型
**参数单位：**无
**取值范围：**0 \~ 30
**默认值：**4。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### m_err_sql_dialect
**参数说明：**M-Compatibility模式数据库行为配置项。用于控制错误码信息的显示方式。
**参数类型：**字符串
**参数单位：**无
**取值范围：**
- GaussDB：表示报错信息（ERRCODE和SQLSTATE）使用GaussDB内核的错误码信息。
- MySQL：表示报错信息（ERRCODE和SQLSTATE）使用M-Compatibility模式数据库的错误码信息，即将GaussDB数据库的错误码和SQLSTATE替换为M-Compatibility模式数据库的错误码和SQLSTATE。
- MySQL_Only_Errcode：表示错误码（ERRCODE）使用M-Compatibility模式数据库的错误码，SQLSTATE使用GaussDB内核的SQLSTATE。
**默认值：**"GaussDB"
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_m_format_hook
**参数说明：**M-Compatibility模式数据库行为配置项。该参数控制M-Compatibility模式hook是否生效。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示M-Compatibility模式数据库允许挂载对应解析执行hook。
- off：表示M-Compatibility模式数据库不挂载对应解析执行hook。
**默认值：**on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**当前参数仅针对当前未完全适配的外部工具使用，不允许用户使用。
**设置不当的风险与影响：**无
#### enable_m_format_fix_strfunc_rettype
**参数说明：**M-Compatibility模式数据库行为配置项。该参数控制M-Compatibility模式下部分字符串函数（具体见下方表格说明）中间处理过程的函数返回值类型。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示部分字符串函数的返回值类型从解析到执行阶段都保持不变。
- off：表示部分字符串函数的返回值类型从解析到执行阶段可能由于字符序导致变化。
**默认值：**on
**设置方式：** 该参数属于SUSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**无
表16受影响的字符串函数列表 
| 序号 | 函数名             |
|:---|:---|
| 1  | left            |
| 2   | right          |
| 3  | lower            |
| 4     | lcase            |
| 5  | ucase            |
| 6  | upper          |
| 7     | lpad           |
| 8    | rpad             |
| 9   | ltrim           |
| 10  | rtrim            |
| 11   | replace          |
| 12  | repeat           |
| 13  | substr          |
| 14   | substring        |
| 15  | substring_index |
| 16     | mid            |
| 17   | concat         |
| 18    | concat_ws       |
| 19    | reverse         |
| 20 | elt            |
| 21  | make_set       |
| 22 | char            |
| 23  | export_set     |
   
#### lower_case_table_names
**参数说明**：该参数用于控制在M-Compatibility模式数据库下，查询用户表名（包括表别名）、用户视图名、Schema名（内部库名）以及information_schema系统视图中以上对象对应字段的值的大小写是否敏感。
**参数类型：**整型
**参数单位：**无
**取值范围**：
- 0：用户表名、用户视图名、Schema名（内部库名）使用CREATE TABLE、CREATE VIEW、CREATE SCHEMA（CREATE DATABASE）语句中指定的字母大小写格式存储在系统表上。information_schema系统视图中以上对象对应字段的值名称比较区分大小写。
- 1：用户表名在系统表上以小写格式存储，名称比较不区分大小写；在存储和查找操作时，将所有用户表名转换为小写格式。此行为也适用于Schema名（内部库名）、表别名、用户视图名和information_schema系统视图中以上对象对应字段的值。
**默认值：**0
**设置方式：**该参数需要在数据库初始化时指定，如未指定，默认行为表示大小写敏感。可通过以下方式用于指定控制大小写行为：
```
--gsinit-parameter='--lower_case_table_names=1'；-- 大小写不敏感
--gsinit-parameter='--lower_case_table_names=0'；-- 大小写敏感
```
**设置建议：**推荐使用默认值。在需要控制M-Compatibility模式数据库查询用户表名（包括表别名）、用户视图、Schema名（内部库名）以及information_schema系统视图中以上对象对应字段的值大小写不敏感时，请将该参数设置为1。
**设置不当的风险与影响：**无
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/notice_3.0-zh-cn.png)
- 以下场景可能会导致数据丢失，请谨慎操作：
  - 禁止在两个lower_case_table_names参数不同的实例之间进行导入导出、逻辑解码或备份恢复操作。
  
  - 禁止在两个lower_case_table_names参数不同的实例之间创建容灾关系。
  
  - 该参数在安装数据库时指定，禁止在数据库启动后或在升级过程中对该参数进行修改，运行过程中或升级过程中修改可能会导致数据丢失，并且无法保证information_schema系统视图字段的值的大小写敏感性是否正确。
   
- 对于非M-Compatibility模式数据库中的系统函数，当入参涉及用户表名（包括表别名）、用户视图名以及Schema名（内部库名）时，无法保证参数lower_case_table_names设置为1后，大小写敏感的正确性。
 
#### gs_format_behavior_compat_options
**参数说明：**gs_format_behavior_compat_options用于选择GaussDB内部系统函数配置项。多租场景下，该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表17]中的兼容性配置项，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开。在PDB场景内，若未设置该参数，则承接来自全局的设置。
**默认值：**""
 表17gs_format_behavior兼容性配置项 
| 兼容性配置项                | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
|:---|:---|
| sqrt_karatsuba       | - 设置此参数：表示在调用sqrt平方根函数时使用Karatsuba平方根算法，Karatsuba算法性能更高但是在极少数情况下精度可能会和牛顿迭代算法不一致。  - 不设置此参数：在计算sqrt平方根算法时会使用默认的牛顿迭代算法进行平方根的计算。                                                                                                                                |
| allow_textconcat_null | - 设置此参数：在PG兼容模式下字符串和null值拼接会返回对应的字符串的值。 ``` -- 在PG兼容模式下执行 gaussdb=# set gs_format_behavior_compat_options='allow_textconcat_null'; SET gaussdb=# select 'a' || null || 'b'; ?column? ---------- ab (1 row) ```   - 不设置此参数：在PG兼容模式下字符串和null值拼接会返回NULL。   |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**控制一些兼容性特性是否可用，若要更改，请在理解参数含义后谨慎操作，避免因误操作产生意料之外的风险。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### support_zero_character
**参数说明** **：**当数据中包含Unicode编码为\\u0000的字符（以下简称空字符）时，数据库是否取消对空字符的校验并且正确处理而不进行截断操作。
**参数类型：**布尔型
**参数单位：**无
**取值范围：**
- on：表示开启，数据库取消对空字符的校验，能够正确插入和处理空字符，使数据在处理过程中不发生截断。
- off：表示关闭，数据库保留对空字符的校验，部分函数在处理空字符时会发生报错或数据截断。
**默认值** **：**off
**设置方式** **：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议** **：**推荐使用默认值，仅在数据中存在空字符且需要对空字符进行正确处理时开启该参数。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 该参数仅在数据库兼容性为A兼容模式且所有节点都设置为support_zero_character=on时生效。
- 当support_zero_character=on时，如果数据类型为CHAR(n)、CHARACTER(n)、NCHAR(n)、VARCHAR(n)、CHARACTER VARYING(n)、VARCHAR2(n)、NVARCHAR2(n)、TEXT或CLOB类型，数据库可以正确插入并处理空字符；如果包含空字符的字符串数据可以显式转换为JSON/JSONB、XML、XMLTYPE、数值类型、货币类型、时间类型、几何类型、网络地址类型、位串类型、文本搜索类型、HLL类型、范围类型、对象标识符类型、账本数据库类型、aclitem类型或向量类型时，会在空字符处发生截断；如果字符串类型显式转换为UUID类型时，会在空字符处发生报错。
- 数据库仅支持以下写入空字符的方式：
  - 通过JDBC连接数据库时，空字符可以通过文本方式写入数据库。
  
  - 通过dbe_raw.cast_to_varchar2函数直接将空字符编码写入数据库。
  
  - 通过copy/gs_loader工具将空字符编码写入数据库。
   
- 在开启GUC参数时，不同字符集之间进行转换时，空字符会直接返回，不再发生报错。
- gsql客户端版本应与数据库版本匹配，在开启GUC参数时，若gsql端接收到的数据中包含空字符，gsql工具会将空字符转换为空格后进行打印输出。若使用505.2.0之前版本的gsql工具连接数据库，包含空字符的数据仍存在显示被截断的情况。
- 当开启GUC参数时，空字符在[表 空字符支持的系统函数和高级包函数列表]所列的函数、高级包函数中的表现为：函数能够正常处理空字符，不会发生在空字符处截断的情况。
- 部分高级包接口入参为Schema名或object名，理论上不能含有空字符，因此对[表18 入参包含空字符进行报错处理的函数]中的函数添加空字符校验，当入参包含空字符时进行报错处理（原表现为空字符后数据被截断）。
- 当support_zero_character=on时，若处理的数据中不包含空字符，函数性能无明显劣化；若处理的数据中包含空字符，对比相同数量的有效字符时，initcap、upper、lower、nls_upper、nls_lower函数性能劣化程度与数据中空字符个数紧密相关，即空字符个数越多，性能劣化越严重。
- 当support_zero_character=on时，若逻辑解码工具读取到数据中包含的空字符，则会将空字符转换为空格后进行打印输出（原表现为空字符后数据被截断）。
 
 表18空字符支持的系统函数和高级包函数列表 
| 序号     | 函数名/高级包函数名                                                                                                                                                                                                                                                                                                          |
|:---|:---|
| 1    | btrim(string text \[, characters text\])                                                                                                                                                                                                                                                                          |
| 2     | char_length(string) 或 character_length(string)                                                                                                                                                                                                                                                                     |
| 3    | chr(cvalue int\|bigint)                                                                                                                                                                                                                                                                                            |
| 4     | chr(integer)                                                                                                                                                                                                                                                                                                       |
| 5     | coalesce(expr1, expr2, ..., exprn)                                                                                                                                                                                                                                                                                |
| 6       | concat(str1,str2)                                                                                                                                                                                                                                                                                                |
| 7    | concat_ws(sep text, str"any" \[, str"any" \[, ...\] \])                                                                                                                                                                                                                                                             |
| 8      | convert(string bytea, src_encoding name, dest_encoding name)                                                                                                                                                                                                                                                         |
| 9      | convert_from(string bytea, src_encoding name)                                                                                                                                                                                                                                                                     |
| 10   | convert_to(string text, dest_encoding name)                                                                                                                                                                                                                                                                         |
| 11    | decode(base_expr, compare1, value1, Compare2,value2, ... default)                                                                                                                                                                                                                                                    |
| 12    | dump(expr\[, return_fmt \[, start_position \[, length \] \] \])                                                                                                                                                                                                                                                    |
| 13    | encode(data bytea, format text)                                                                                                                                                                                                                                                                                  |
| 14    | format(formatstr text \[, str"any" \[, ...\] \])                                                                                                                                                                                                                                                                   |
| 15   | greatest(expr1 \[, ...\])                                                                                                                                                                                                                                                                                         |
| 16    | group_concat(\[DISTINCT \| ALL\] expression \[,expression ...\] \[ORDER BY { expression \[ \[ ASC \| DESC \| USING operator \] \| nlssort_expression_clause \] \[ NULLS { FIRST \| LAST } \] } \[,...\]\] \[SEPARATOR str_val\])                                                                                  |
| 17    | initcap(string)                                                                                                                                                                                                                                                                                                   |
| 18     | instr(string,substring\[,position,occurrence\]) instr(text,text,int,int)                                                                                                                                                                                           |
| 19   | instrb(text,text,int,int)                                                                                                                                                                                                                                                                                           |
| 20   | least(expr1 \[, ...\])                                                                                                                                                                                                                                                                                               |
| 21    | left(str text, n int)                                                                                                                                                                                                                                                                                              |
| 22    | length(string) length(string bytea, encoding name )                                                                                                                                                                                                                  |
| 23   | lengthb(text/bpchar)                                                                                                                                                                                                                                                                                                |
| 24    | listagg(expression \[, delimiter\]) WITHIN GROUP(ORDER BY order-list)                                                                                                                                                                                                                                             |
| 25    | lower(string)                                                                                                                                                                                                                                                                                                       |
| 26  | lpad(string text, length int \[, fill text\])                                                                                                                                                                                                                                                                     |
| 27     | ltrim(string \[, characters\])                                                                                                                                                                                                                                                                                     |
| 28    | nls_lower(string \[, nlsparam\])                                                                                                                                                                                                                                                                                  |
| 29     | nls_upper(string \[, nlsparam\])                                                                                                                                                                                                                                                                                   |
| 30    | nullif(expr1, expr2)                                                                                                                                                                                                                                                                                              |
| 31    | nvl( expr1 , expr2 )                                                                                                                                                                                                                                                                                               |
| 32     | nvl2( expr1 , expr2，expr3 )                                                                                                                                                                                                                                                                                        |
| 33   | overlay(string placing string FROM int \[for int\])                                                                                                                                                                                                                                                               |
| 34   | position(substring in string)                                                                                                                                                                                                                                                                                      |
| 35     | quote_nullable(string text)                                                                                                                                                                                                                                                                                         |
| 36   | regexp_count(string text, pattern text \[, position int \[, flags text\]\])                                                                                                                                                                                                                                        |
| 37    | regexp_instr(string text, pattern text \[, position int \[, occurrence int \[, return_opt int \[, flags text\]\]\]\])                                                                                                                                                                                             |
| 38     | regexp_like(text,text,text) regexp_like(source_string, pattern \[, match_parameter\])                                                                                                                                                                            |
| 39    | regexp_matches(string text, pattern text \[, flags text\])                                                                                                                                                                                                                                                       |
| 40     | regexp_replace(string, pattern, replacement \[,flags \])                                                                                                                                                                                                                                                            |
| 41   | regexp_split_to_array(string text, pattern text \[, flags text \])                                                                                                                                                                                                                                                  |
| 42     | regexp_split_to_table(string text, pattern text \[, flags text\])                                                                                                                                                                                                                                                |
| 43   | regexp_substr(source_char, pattern) regexp_substr(string text, pattern text \[, position int \[, occurrence int \[, flags text\]\]\])                                                                                                                               |
| 44    | repeat(string text, number int )                                                                                                                                                                                                                                                                                   |
| 45    | replace(string text, from text, to text) replace(string, substring)                                                                                                                                                                                             |
| 46    | reverse(str)                                                                                                                                                                                                                                                                                                        |
| 47    | right(str text, n int)                                                                                                                                                                                                                                                                                           |
| 48    | rpad(string text, length int \[, fill text\])                                                                                                                                                                                                                                                                     |
| 49    | rtrim(string \[, characters\])                                                                                                                                                                                                                                                                                    |
| 50    | similar_escape(pat text, esc text)                                                                                                                                                                                                                                                                                  |
| 51   | split_part(string text, delimiter text, field int)                                                                                                                                                                                                                                                                  |
| 52    | string \[NOT\] LIKE pattern \[ESCAPE escape-character\]                                                                                                                                                                                                                                                          |
| 53    | string \|\| string 或 string \|\| non-string 或 non-string \|\| string                                                                                                                                                                                                                                              |
| 54    | string_agg(expression, delimiter)                                                                                                                                                                                                                                                                                 |
| 55    | strpos(string, substring)                                                                                                                                                                                                                                                                                         |
| 56    | substr(string,from) substr(bytea,from,count) substr(string,from,count)                                                                                                                                                 |
| 57     | substrb(text,int) substrb(text,int,int)                                                                                                                                                                                                                              |
| 58     | substring(string \[from int\] \[for int\]) substring(string from pattern for escape) substring(string from pattern) substring_inner(string \[from int\] \[for int\]) |
| 59    | translate(string text, from text, to text)                                                                                                                                                                                                                                                                          |
| 60      | trim(\[leading \|trailing \|both\] \[characters\] from string)                                                                                                                                                                                                                                                    |
| 61  | unistr(string)                                                                                                                                                                                                                                                                                                      |
| 62     | upper(string)                                                                                                                                                                                                                                                                                                     |
| 63  | PKG_UTIL.LOB_GET_LENGTH                                                                                                                                                                                                                                                                                             |
| 64      | PKG_UTIL.LOB_READ                                                                                                                                                                                                                                                                                                   |
| 65  | PKG_UTIL.LOB_WRITE                                                                                                                                                                                                                                                                                                |
| 66      | PKG_UTIL.LOB_APPEND                                                                                                                                                                                                                                                                                                 |
| 67    | PKG_UTIL.LOB_COMPARE                                                                                                                                                                                                                                                                                              |
| 68     | PKG_UTIL.LOB_MATCH                                                                                                                                                                                                                                                                                                 |
| 69   | PKG_UTIL.LOB_READ_HUGE                                                                                                                                                                                                                                                                                             |
| 70   | PKG_UTIL.LOB_WRITEAPPEND_HUGE                                                                                                                                                                                                                                                                                       |
| 71    | PKG_UTIL.LOB_APPEND_HUGE                                                                                                                                                                                                                                                                                            |
| 72     | PKG_UTIL.LOB_COPY_HUGE                                                                                                                                                                                                                                                                                             |
| 73     | PKG_UTIL.LOB_CONVERTTOBLOB_HUGE                                                                                                                                                                                                                                                                                      |
| 74   | PKG_UTIL.IO_PRINT                                                                                                                                                                                                                                                                                                   |
| 75    | PKG_UTIL.RAW_CAST_FROM_VARCHAR2                                                                                                                                                                                                                                                                                     |
| 76    | PKG_UTIL.FILE_READ                                                                                                                                                                                                                                                                                                 |
| 77     | PKG_UTIL.FILE_READLINE                                                                                                                                                                                                                                                                                            |
| 78     | PKG_UTIL.APP_READ_CLIENT_INFO                                                                                                                                                                                                                                                                                    |
| 79  | PKG_UTIL.APP_SET_CLIENT_INFO                                                                                                                                                                                                                                                                                         |
| 80    | PKG_UTIL.LOB_CONVERTTOBLOB                                                                                                                                                                                                                                                                                         |
| 81  | PKG_UTIL.LOB_CONVERTTOCLOB                                                                                                                                                                                                                                                                                        |
| 82     | PKG_UTIL.MATCH_EDIT_DISTANCE_SIMILARITY                                                                                                                                                                                                                                                                           |
| 83     | PKG_UTIL.RAW_CAST_TO_VARCHAR2                                                                                                                                                                                                                                                                                     |
| 84    | PKG_UTIL.APP_SET_MODULE                                                                                                                                                                                                                                                                                            |
| 85     | PKG_UTIL.APP_READ_MODULE                                                                                                                                                                                                                                                                                          |
| 86   | PKG_UTIL.APP_SET_ACTION                                                                                                                                                                                                                                                                                           |
| 87   | PKG_UTIL.APP_READ_ACTION                                                                                                                                                                                                                                                                                           |
| 88  | DBE_OUTPUT.PRINT_LINE                                                                                                                                                                                                                                                                                               |
| 89     | DBE_OUTPUT.PRINT                                                                                                                                                                                                                                                                                                   |
| 90   | DBE_OUTPUT.GET_LINE                                                                                                                                                                                                                                                                                                |
| 91     | DBE_OUTPUT.GET_LINES                                                                                                                                                                                                                                                                                              |
| 92    | DBE_OUTPUT.PUT                                                                                                                                                                                                                                                                                                     |
| 93     | DBE_OUTPUT.PUT_LINE                                                                                                                                                                                                                                                                                                |
| 94    | DBE_UTILITY.CANONICALIZE                                                                                                                                                                                                                                                                                           |
| 95    | DBE_UTILITY.COMMA_TO_TABLE                                                                                                                                                                                                                                                                                         |
| 96    | DBE_UTILITY.NAME_TOKENIZE                                                                                                                                                                                                                                                                                           |
| 97      | DBE_UTILITY.TABLE_TO_COMMA                                                                                                                                                                                                                                                                                        |
| 98    | DBE_UTILITY.CANONICALIZE_RET                                                                                                                                                                                                                                                                                        |
| 99     | DBE_UTILITY.COMMA_TO_TABLE_FUNC                                                                                                                                                                                                                                                                                   |
| 100     | DBE_UTILITY.NAME_SEPARATE                                                                                                                                                                                                                                                                                         |
| 101   | DBE_UTILITY.NAME_TOKENIZE_FUNC                                                                                                                                                                                                                                                                                      |
| 102    | DBE_UTILITY.NAME_TOKENIZE_LOWER                                                                                                                                                                                                                                                                                    |
| 103 | DBE_UTILITY.NAME_TOKENIZE_LOWER_FUNC                                                                                                                                                                                                                                                                               |
| 104 | DBE_UTILITY.TABLE_TO_COMMA_FUNC                                                                                                                                                                                                                                                                                   |
   
 表19入参包含空字符进行报错处理的函数 
| 序号  | 高级包函数名                                            |
|:---|:---|
| 1    | PKG_UTIL.SESSION_SET_CONTEXT                      |
| 2  | PKG_UTIL.UTILITY_COMPILE_SCHEMA                  |
| 3  | PKG_UTIL.GS_COMPILE_SCHEMA                         |
| 4    | DBE_UTILITY.NAME_RESOLVE                          |
| 5    | DBE_UTILITY.COMPILE_SCHEMA                        |
| 6   | DBE_UTILITY.SEARCH_CLASS_WITH_NSPOID_ONAME_TYPE |
| 7 | DBE_UTILITY.SEARCH_OBJECTS                       |
| 8  | DBE_UTILITY.SEARCH_OBJECTS_SYNONYM_FILL_SCHEMA  |
| 9   | DBE_UTILITY.SEARCH_PROCEDURE_WITH_NSPOID_ONAME  |
| 10 | DBE_UTILITY.SEARCH_SYNONYM_WITH_NSPOID_ONAME       |
| 11   | PG_CATALOG.GS_COMPILE_SCHEMA                       |
   
#### enable_case_intervaltonumeric
**参数说明** **：**控制CASE语句中是否支持INTERVAL转NUMERIC，该参数仅在A兼容模式下生效。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：CASE语句中支持INTERVAL转NUMERIC。
- off：CASE语句中不支持INTERVAL转NUMERIC。
**默认值** **：**off
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为on，后续修改为off，可能导致现有CASE语句报错。
#### enable_ecpg_cursor_duplicate_operation
**参数说明** **：**ECPG控制在A兼容下是否支持重复打开/关闭游标，仅在ECPG连接A兼容数据库时生效。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：ECPG连接A兼容数据库时，支持重复打开/关闭游标。
- off：ECPG连接A兼容数据库时，不支持重复打开/关闭游标。
**默认值** **：**on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为off，重复打开/关闭游标时会报错。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
直接安装当前版本数据库时，该参数默认值为on。从历史版本升级上来的数据库，若升级前的基础版本不支持该参数，则升级后该参数默认值为off；若升级前的基础版本支持该参数，升级后保持该参数当前设置。
#### format_pg_to_timestamp
**参数说明** **：** 在PG模式下，控制to_timestamp(string \[, fmt\])函数的行为。开启后，如果有不支持的格式，自动跳过，当前版本不支持FF，FF7，FF8，FF9，RR，RRRR，SYYYY，x，X等格式；支持早于294277-01-01 00:00:00之前的时间日期和负数年份（转化成公元前）；FF1-FF6会把超出精确度的毫秒四舍五入；当时间日期中相同项冲突时（例如DDD和DD所指的天数不同时）返回一个格式正确的时间不会报错，具体冲突行为如[表20]所示。多租场景下，该参数可在PDB级别设置。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：实现上述功能。
- off：取消实现上述功能。
**默认值** **：**on。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**开启会导致GaussDB不支持的fmt失效。
 表20to_timestamp fmt冲突 
| 模式           | 描述                                                                                                                                               |
|:---|:---|
| SSSSS与时间冲突 | 保留时间（分钟，小时）中的值以及SSSSS中的秒数部分的值。                                                                                                                    |
| W，J与时间日期冲突   | 优先级：J，W，mmdd按顺序进行覆盖。 W：未指定时，默认为星期三。 默认行为：W覆盖mmdd。 |
| SSSSS与SS冲突  | 保留SS，舍弃SSSSS。                                                                                                                                    |
| DDD与日期冲突      | 舍弃DDD。                                                                                                                                         |
   
#### synonym_priv_strict_check
**参数说明** **：**控制通过同义词搜索对象时，是否检查同义词关联对象的访问权限。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：通过同义词检索对象时，检查是否具有同义词关联对象的访问权限。
- off：通过同义词检索对象时，不检查是否具有同义词关联对象的访问权限。
**默认值** **：**
- 直接安装新版本时，默认值为on。
- 从历史版本升级上来的数据库，如果升级的基础版本不支持该GUC参数，默认值为off；如果升级的基础版本支持该GUC参数，默认值为on。
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为off，通过同义词访问对象时，不检查对象的访问权限，可能构成越权风险。
#### forbid_public_funcname_same_with_sysfunc
**参数说明** **：**控制在创建函数及RENAME函数时，是否禁止PUBLIC函数与pg_catalog下的系统函数名称相同。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：创建函数及RENAME函数时，禁止PUBLIC函数与pg_catalog下的系统函数名称相同。
- off：创建函数及RENAME函数时，允许PUBLIC函数与pg_catalog下的系统函数名称相同。
**默认值** **：**
- 直接安装新版本时，默认值为on。
- 从历史版本升级上来的数据库，如果升级的基础版本不支持该GUC参数，默认值为off；如果升级的基础版本支持该GUC参数，默认值为on。
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为off，允许PUBLIC函数与pg_catalog下的系统函数名称相同。
#### a_format_func_col_name
**参数说明：**数据库A兼容模式系统函数兼容性行为配置项。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 当前只支持[表21]的信息，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开。
**默认值：**""（空字符串）。在PDB场景内，若未设置该参数，则继承来自全局的设置。
 表21系统函数兼容性配置项 
| 系统函数兼容性配置项 | 兼容性行为控制                           |
|:---|:---|
| user       | 开启该参数后，SELECT user;返回的投影列名为user。 |
   
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**根据数据库兼容对象进行调整。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_cursor_with_hold
**参数说明** **：**在A兼容模式下，控制游标是否具有WITH HOLD功能。当开启enable_cursor_with_hold后，在创建游标时，未明确指定WITHOUT HOLD关键字且SELECT子句不包含FOR UPDATE或FOR SHARE子句时，创建的游标默认行为具有WITH HOLD功能。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：创建游标时，未明确指定WITHOUT HOLD关键字且SELECT子句不包含FOR UPDATE或FOR SHARE子句时，创建的游标默认行为具有WITH HOLD功能。此时，CURSOR cursor_name FOR query;语义与CURSOR cursor_name WITH HOLD FOR query;等效。
- off：创建游标时，未指定WITH HOLD或WITHOUT HOLD关键字时，默认行为是WITHOUT HOLD。
**默认值** **：**off
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。仅支持在会话中设置该参数。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为on，所有游标不会被释放，在会话中可能会存在内存膨胀的风险。
#### sql_select_limit
**参数说明：**M-Compatibility模式数据库行为配置项。该参数用于在执行查询时最多返回给客户端的行数限制。多租场景下，该参数可在PDB级别设置。
**参数类型** **：**整型
**参数单位：**无
**取值范围：**0 \~ 9223372036854775807
**默认值：**9223372036854775807
**设置方式：** 该参数属于USERSET类型参数，但仅支持SESSION级设置，请参见[表2](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t290c8f15953843db8d8e53d867cd893d)中方式三对应设置方法进行设置。取值不能带单位。
**设置建议：**推荐使用默认值，在会话级设置。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### modify_function_property
**参数说明**：在非M兼容模式下，该参数用于控制相关系统函数的属性。
**参数类型：**字符串
**参数单位：**无
**取值范围** ：当前只支持[表22]中的配置项，当设置多个兼容性配置项时，相邻配置项之间用逗号隔开。在PDB场景内，若未设置该参数，则承接来自全局的设置。
**默认值：**新安装数据库默认值为"3257,5562,4164,4073"；若升级的基础版本不存在该GUC参数，默认为""；若升级的基础版本存在该GUC参数，保留原设置。
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值，不建议修改。
**设置不当的风险与影响：**影响系统函数的属性。
 表22系统函数配置项 
| 系统函数对应的oid | 描述                                                                                               |
|:---|:---|
| 3257      | 修改函数pg_catalog.current_timestamp(numeric)的易变性，当该配置项存在于GUC参数中时，函数易变性为 'stable'，不存在时为 'immutable'。 |
| 4073        | 修改函数pg_catalog.text_timestamp(text)的易变性，当该配置项存在于GUC参数中时，函数易变性为 'stable'，不存在时为 'immutable'。       |
| 4164      | 修改函数pg_catalog.text_date(text)的易变性，当该配置项存在于GUC参数中时，函数易变性为 'stable'，不存在时为 'immutable'。            |
| 5562       | 修改函数pg_catalog.DBTimezone()的易变性，当该配置项存在于GUC参数中时，函数易变性为 'stable'，不存在时为 'immutable'。                |
   
#### forbid_package_spec_circular_dependency
**参数说明** **：**控制PACKAGE包头依赖成环对象有效状态，使用时需要打开enable_force_create_obj参数。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：PACKAGE包头依赖成环时对象状态为失效。
- off：PACKAGE包头依赖成环时对象状态为有效。
**默认值** **：**
- 直接安装新版本时，默认值为on。
- 从历史版本升级上来的数据库，如果升级的基础版本不支持该GUC参数，默认值为off；如果升级的基础版本支持该GUC参数，默认值为on。
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为off，PACKAGE包头依赖成环时对象状态可以变为有效。
 #### forbid_hold_cursor_with_forupdate
**参数说明** **：**用于控制存储过程中带有FOR UPDATE、FOR NO KEY UPDATE、FOR SHARE或FOR KEY SHARE特性的游标循环或for loop查询语句行为，是否在执行事务提交/回滚操作后的下次循环访问游标时报错。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：开启参数说明中的报错行为。
- off：关闭参数说明中的报错行为。
**默认值** **：**on
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为off，存储过程在执行事务提交/回滚操作期间可能报错，或提交/回滚后下次循环访问游标时丢失FOR UPDATE/FOR NO KEY UPDATE/FOR SHARE/FOR KEY SHARE特性。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
直接安装当前版本数据库时，该参数默认值为on。从历史版本升级上来的数据库，若升级前的基础版本不支持该参数，则升级后该参数默认值为off；若升级前的基础版本支持该参数，升级后保持该参数当前设置。
#### adjust_systemview_priority
**参数说明** **：**A兼容模式下，开启该参数后，同名视图优先访问用户自定义的视图。
**参数类型：**布尔型
**参数单位：**无
**取值范围** **：**
- on：表示开启参数，同名视图优先访问用户自定义的视图。
- off：表示关闭参数，同名视图优先访问系统视图。
**默认值** **：**off
**设置方式：** 该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**若设置为on，同名视图会优先访问用户自定义的视图。
 #### using_danger_feature
**参数说明** **：**用于控制是否开启危险特性。
**参数类型**：字符串
**参数单位：**无
**取值范围** **：** 当前只支持[表23]中的信息，当设置多个值时，相邻的值使用逗号隔开。
**默认值** **：**"none"，表示不开启危险特性。
 表23危险特性配置项 
| 危险特性配置项         | 行为控制                                                                                                                                                                                                                                                                                                                                                                   |
|:---|:---|
| operator_class  | 设置该选项时，允许系统管理员创建操作符类。在创建操作符类时，要求传入函数的入参类型和索引类型保持一致或能正常进行类型转换，否则会造成不可预知的后果。                                                                                                                                                                                                                                                                                            |
| alter_function | - 设置该选项时，可以对高级包所属模式、m_schema、information_schema、sqladvisor、sys、pg_toast以及dbe_sql_util中的函数，进行修改其函数名称、函数所有者以及函数所属模式的操作。  - 未设置该选项时，禁止对以上模式中的函数名称、函数所有者以及函数所属模式进行修改。   |
   
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 推荐使用默认值**。**
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改，避免出现意料之外的结果。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 直接安装当前版本数据库时，该参数默认值为"none"。从历史版本升级到当前版本时，如果升级的基础版本不支持该参数，该参数默认值为"operator_class, alter_function"；如果升级的基础版本支持该参数，升级后保持该参数当前设置。
- 当"none"和其它配置项共同设置时，"none"配置项不生效。
 
#### disable_operator
**参数说明**：禁用指定的操作符，该参数设置的操作符将不能被调用。当某一系统操作符不能满足用户需求并且需要使用自定义操作符时，可使用该功能。该参数可在PDB级别设置。
**参数类型：**字符串
**参数单位：**无
**取值范围：** 字符串，由若干个操作符OID值用逗号隔开组成。操作符OID可以通过查询系统表[PG_OPERATOR](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1246.html)获得。
**默认值：**""。在PDB场景内，若未设置该参数，则继承来自全局的设置。
**设置方式：** 该参数属于SUSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### enable_xmltype_ignore_format
**参数说明** **：**用于控制xmltype类型的数据是否使用content格式校验。
**参数类型**：布尔型
**参数单位：**无
**取值范围** **：**
- on：表示开启参数，支持xmltype类型的数据使用content格式校验。
- off：表示关闭参数，支持xmltype类型的数据使用document格式校验。
**默认值** **：**off
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 该参数为逃生参数，非必要用户不要自行设置**。**
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
开启enable_xmltype_ignore_format参数时，目前仅支持以下两种场景使用content格式校验输入数据：
- 从unknown、unspecified类型转换至xmltype类型，转换原理请参见[类型转换](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0128.html)。
- 通过调用xmltype函数，例如：xmltype('123')。
 
 #### load_data_behavior_compat_options
**参数说明：**控制sql_compatibility='B'以及M-Compatibility模式数据库行为配置项。用于控制LOAD DATA语法导入数据的行为方式。
**参数类型：**枚举类型
**参数单位：**无
**取值范围：** 如[表24]所示。
 表24load_data_behavior_compat_options配置项说明 
| 兼容性配置项                  | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|
| none                       | 不使用任何兼容性配置项。 当使用none与其他兼容性配置项组合设置时，none选项不生效。如"SET load_data_behavior_compat_options='none,new_escape_string';"等价于"SET load_data_behavior_compat_options='new_escape_string';"。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| new_escape_string       | 控制LOAD DATA导入数据时，支持的转义序列。默认的转义符为'\\'。 - 未设置new_escape_string选项时，支持的转义序列如下： - \\a\[b\[c\]\]：该转义序列中a、b、c均为八进制数字（0\~7），表示一个由八进制数字构成的数值，系统会将其解析为对应的字节值。例如，\\141的八进制值为141，对应十进制97，表示ASCII字符（字符a的ASCII编码值为97）。  - \\xhh：该转义序列中h表示一个十六进制数字（0\~9、a\~f、A\~F）。hh表示由两位十六进制数字构成的数值，系统会将其解析为对应的字节值。例如，\\x6a的十六进制值为6A，对应十进制106，表示ASCII字符'j'（字符'j'的ASCII编码值为106）。  - \\r：回车符。  - \\n：换行符。  - \\b：退格符。  - \\v：垂直制表符。  - \\t：水平制表符。  - \\f：换页符。  - \\0：0字符。    - 设置new_escape_string选项时，支持的转义序列如下： - \\r：回车符。   - \\n：换行符。   - \\b：退格符。   - \\t：水平制表符。  - \\0：0字符。  - \\Z：ASCII 26(Control Z)。     控制LOAD DATA导入数据时，是否对指定的行终结符做转义处理。 - 未设置new_escape_string选项时，行终结符指定为如下内容时，会将其转义为对应的控制字符： - 0x0A或\\n：换行符。  - 0x0D0A或\\r\\n：回车符和换行符。  - 0x0D或\\r：回车符。  - 0x09或\\t：水平制表符。  - 0x0B或\\v：垂直制表符。  - 0x0C或\\f：换页符。    - 设置new_escape_string选项时，不会对指定的行终结符做转义处理。   |
| fixed_row_column_division | 在控制LOAD DATA导入数据时，可通过该选项调整对源数据文件的行、列切分行为。包括但不限于以下场景的处理方式受该选项控制： - 当源数据文件的行末无行分隔符（lines_terminated_by），且最后一行的最后一列数据以包围符（enclosed_by）开头时： - 未设置该选项时，导入过程中会丢失1个字节。  - 设置该选项后，导入过程中不会丢失数据。    - 当转义符后紧接列分隔符（fields_terminated_by）时： - 未设置该选项时，列分隔符不会被转义为普通字符。  - 设置该选项后，列分隔符会被转义为普通字符。    - 当转义符后紧接包围符时： - 未设置该选项时，包围符不会被转义为普通字符。  - 设置该选项后，包围符会被转义为普通字符。    - 当转义符后紧接非显式指定的行分隔符时： - 未设置该选项时，行分隔符不会被转义为普通字符。  - 设置该选项后，行分隔符会被转义为普通字符。    - 当不指定行分隔符时： - 未设置该选项时，行分隔符为文件中首次匹配的'\\r\\n'，'\\n'，或'\\r'。  - 设置该选项时，行分隔符为'\\n'。    - 当指定转义符和包围符为相同字符时： - 未设置该选项时，会对'\\t'、'\\n'等转义序列进行转义。  - 设置该选项时，不会对'\\t'、'\\n'等转义序列进行转义。    - 在M-Compatibility模式下，指定LOCAL选项进行远程传输时： - 未设置该选项时，指定的行起始符（lines_starting_by）不会生效。当源数据存在整行的'\\.'字符串时，'\\.'及后续的数据不会被导入。  - 设置该选项时，指定的行起始符能够生效。当源数据存在整行的'\\.'字符串时，'\\.'及后续的数据会被导入。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
   
**默认值：**
- 新安装的数据库："new_escape_string, fixed_row_column_division"。
- 从历史版本升级上来的数据库，若历史版本不支持该GUC参数，升级后的默认值为"none"；若历史版本支持该GUC参数，升级后默认值保留原设置。
**设置方式：** 该参数属于USERSET类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
#### modify_function_property_json
**参数说明**：该参数以JSON格式控制系统函数的属性。
- oid：目标系统函数的oid。 取值范围为0\~10000。
- compatibility：数据库兼容模式。取值范围为A、M、OTHER。
- property_list：函数属性列表，可配置多个属性项。
  - property_name：属性名称，目前支持proshippable、provolatile。
  
  - property_value：属性值，取值需符合对应属性的取值范围。proshippable的取值范围为t、f，provolatile的取值范围i、s、v。
   
**参数类型：**字符串
**参数单位：**无
**取值范围**：修改配置文件：0 \~ 50000个字符；gs_guc设置：0 \~ 4099个字符。
**默认值：**
- 新安装数据库默认值为 '\[{"oid": 4162,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4163,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4186,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4187,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4905,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4906,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4907,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4908,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4909,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4910,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4911,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4912,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4913,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 4914,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 6286,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 6287,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 6288,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 6289,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]},
  {"oid": 6307,"compatibility":"A", "property_list": \[{"property_name": "provolatile", "property_value": "v"}\]},
  {"oid": 4079,"compatibility":"M", "property_list": \[{"property_name": "provolatile", "property_value": "s"}\]}\]'。
  

- 若升级的基础版本不存在该GUC参数，默认为""。
- 若升级的基础版本存在该GUC参数，保留原设置。
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值，不建议修改。
**设置不当的风险与影响：**影响系统函数的属性。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
若modify_function_property和modify_function_property_json的配置有冲突，以modify_function_property的配置为准。
#### illegal_character_strict_check
**参数说明** **：**用于控制是否开启非法字符校验。
**参数类型**：布尔型
**参数单位：**无
**取值范围** **：**
- on：表示开启参数，支持非法字符校验。当字符串的字节序列无法按编码规则完整解析为合法字符（即实际字节长度不足以构成完整字符）时，判定为非法字符并报错。
- off：表示关闭参数，不支持非法字符校验。
**默认值** **：**
- 新安装的数据库：on。
- 从历史版本升级上来的数据库：若历史版本不支持该GUC参数，升级后的默认值为off；若历史版本支持该GUC参数，升级后默认值保留原设置。
**设置方式：** 该参数属于SIGHUP类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：** 非必要用户不要自行设置**。**
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
 #### disable_unsupported_copy_load_options
**参数说明** **：**用于控制COPY/LOAD DATA非推荐语法对于导入导出时产生异常结果的处理行为。
**参数类型：**布尔型
**取值范围** **：**
- on：表示禁用非推荐语法中可能导致异常结果的操作。
- off：表示不禁用非推荐语法中可能导致异常结果的操作。
**默认值** **：**
- 新安装的数据库：on。
- 对于从历史版本升级到当前版本的数据库：若历史版本不支持该GUC参数，升级后的默认值为off；若历史版本支持该GUC参数，升级后默认值保留原设置。
**设置方式：** 该参数属于POSTMASTER类型参数，请参见[表1](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0993.html#ZH-CN_TOPIC_0000002793699379__zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**设置建议：**推荐使用默认值，不建议修改。
**设置不当的风险与影响：**请在充分理解参数含义，并经过测试验证后进行修改。
