
# 平台和客户端兼容性
很多平台都使用数据库系统，数据库系统的对外兼容性给平台提供了很大的方便。
#### convert_string_to_digit
**参数说明**：设置隐式转换优先级，是否优先将字符串转为数字。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示优先将字符串转为数字。
- off表示不优先将字符串转为数字。
**默认值**：on
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/notice_3.0-zh-cn.png)
该参数调整会修改内部数据类型转换规则，导致不可预期的行为，请谨慎操作。
#### nls_timestamp_format
**参数说明**：设置时间戳默认格式。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围**：字符串
**默认值**：DD-Mon-YYYY HH:MI:SS.FF AM
#### nls_timestamp_tz_format
**参数说明**：设置带时区时间戳默认格式。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围**：字符串，支持格式同nls_timestamp_format。
**默认值**：DD-Mon-YYYY HH:MI:SS.FF AM
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
此参数与在参数a_format_version值为10c和a_format_dev_version值为s1的情况下有效
#### group_concat_max_len
**参数说明：**搭配函数GROUP_CONCAT使用，限制其返回值长度，超长截断。
该参数属于USERSET类型参数，请参考表[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**0-9223372036854775807
**默认值：**1024
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
目前能返回的最大长度是1073741823，超出此长度后会有out of memory的报错。
#### max_function_args
**参数说明**：函数参数最大个数。
该参数属于INTERNAL类型参数，为固定参数，用户无法修改此参数，只能查看。
**取值范围**：整型
**默认值**：8192
#### transform_null_equals
**参数说明：**控制表达式expr = NULL（或NULL = expr）当做expr IS NULL处理。如果expr得出NULL值则返回真，否则返回假。
- 正确的SQL标准兼容的expr = NULL总是返回NULL（未知）。
- Microsoft Access里的过滤表单生成的查询使用expr = NULL来测试空值。打开这个选项，可以使用该接口来访问数据库。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示控制表达式expr = NULL（或NULL = expr）当做expr IS NULL处理。
- off表示不控制，即expr = NULL总是返回NULL（未知）。
**默认值：**off
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
新用户经常在涉及NULL的表达式上语义混淆，故默认值设为off。
#### support_extended_features
**参数说明：**控制是否支持数据库的扩展特性。
该参数属于POSTMASTER类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示支持数据库的扩展特性。
- off表示不支持数据库的扩展特性。
**默认值：**off
#### enable_extension
**参数说明：**控制是否支持创建数据库扩展插件。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示支持创建数据库扩展插件。
- off表示不支持创建数据库扩展插件。
**默认值：**off
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/notice_3.0-zh-cn.png)
扩展功能为内部使用功能，不建议用户使用。
#### sql_compatibility
**参数说明：**控制数据库的SQL语法和语句行为同哪一个主流数据库兼容。该参数属于INTERNAL类型参数，用户无法修改，只能查看。
**取值范围：**枚举型
- A表示同O数据库兼容。
- B表示同MY数据库兼容。
- C表示同TD数据库兼容。
- PG表示同POSTGRES数据库兼容。
**默认值：**A
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/notice_3.0-zh-cn.png)
- 该参数只能在执行CREATE DATABASE命令（详见《开发指南》的"SQL参考 \> SQL语法 \> CREATE DATABASE"章节）创建数据库的时候设置。
- 在数据库中，该参数只能是确定的一个值，要么始终设置为A，要么始终设置为B，请勿任意改动，否则会导致数据库行为不一致。
 
#### b_format_behavior_compat_options
**参数说明：**数据库B模式兼容性行为配置项，该参数的值由若干个配置项用逗号隔开构成。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**字符串
**默认值：**""
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表1 兼容性B模式配置项]。
- 配置多个兼容性配置项时，相邻配置项用逗号隔开，例如：set b_format_behavior_compat_options='enable_set_variables,set_session_transaction';
 
 表1兼容性B模式配置项 
| 兼容性配置项                  | 兼容性行为控制                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|:---|:---|
| 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字符序。  - 设置此配置时，字符类型字段的字符序当表级字符序不为空时继承表级字符序，为空时设置为数据库编码对应的默认字符序。                                                        |
   
#### behavior_compat_options
**参数说明：**数据库兼容性行为配置项，该参数的值由若干个配置项用逗号隔开构成。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**字符串
**默认值：**""
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表2]。
- 配置多个兼容性配置项时，相邻配置项用逗号隔开，例如：set behavior_compat_options='end_month_calculate,display_leading_zero';
 
 表2兼容性配置项 
| **兼容性配置项**                      | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|
| display_leading_zero            | 浮点数显示配置项。控制数值类型中char、character、nchar、varchar、character varying、varchar2、nvarchar2、text、clob等所有字符串类型和float4、float8、numeric等任意精度类型的小数点前零显示。并且length计算数字长度同步显示。 - 不设置此配置项时，对于-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函数计算逻辑配置项。 假定函数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时全局采样会更精确的控制在3万条左右，更好地控制analyze时DBnode端的内存消耗，保证analyze性能的稳定性。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| bind_schema_tablespace          | 绑定模式与同名表空间配置项。 如果存在与模式名sche_name相同的表空间名，那么如果设置search_path为sche_name， default_tablespace也会同步切换到sche_name。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| bind_procedure_searchpath       | 未指定模式名的存储过程中的数据库对象的搜索路径配置项。 在存储过程中如果不显示指定模式名，会优先在存储过程所属的模式下搜索。 如果找不到，则有两种情况： - 若不设置此参数，报错退出。  - 若设置此参数，按照search_path中指定的顺序继续搜索。如果还是找不到，报错退出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| 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             | 控制对整数除法的结果进行范围校验。 若不设置此配置项，则会对除法结果做范围校验，例如，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类型再进行比较。 ``` 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) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| return_null_string              | 控制函数lpad()和rpad()结果为空字符串''的显示配置项。 - 不设置此配置项时，空字符串显示为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（参考《开发指南》的"SQL参考 \> SQL语法 \> MERGE INTO"章节） 和INSERT ... ON DUPLICATE KEY UPDATE（参考《开发指南》的"SQL参考 \> SQL语法 \> INSERT"章节）时，当目标表中一条目标数据与多条源数据冲突时UPDATE行为。 若设置此配置项，当存在上述场景时，该冲突行将会多次执行UPDATE；否则（默认）报错，即MERGE或INSERT操作失败。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| plstmt_implicit_savepoint       | 控制存储过程中更新语句的执行是否拥有独立的子事务。 若设置此配置项，存储过程中每条更新语句前开启隐式保存点，EXCEPTION块中默认回退到最近的保存点，从而保证只回退失败语句的修改。该选项是为了兼容O数据库的EXCEPTION行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| hide_tailing_zero               | numeric显示配置项。不设置此项时，numeric按照指定精度显示。设置此项时，所有输出numeric的场景均隐藏小数点后的末尾0，包括显示指定format精度情况。 ``` 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) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| 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; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| aformat_null_test               | 控制rowtype类型判空逻辑。 设置此项时，对于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时，正则表达式的 flags 参数支持的选项含义有变更： 1. 默认不能匹配 '\\n' 字符。  2. flags 中包含n选项时， . 能够匹配 '\\n' 字符。  3. regexp_replace(source, pattern replacement) 函数替换所有匹配的子串。  4. regexp_replace(source, pattern, replacement, flags) 在 flags值为'' 或者null时，返回值为null。   否则，正则表达式的 flags 参数支持的选项含义： 1. 默认能匹配 '\\n' 字符。  2. flags 中的 n 选项表示按照多行模式匹配。  3. regexp_replace(source, pattern replacement) 函数仅替换第一个匹配到的子串。  4. regexp_replace(source, pattern, replacement, flags) 在 flags值为'' 或者null时，返回值为替换后的字符串。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| compat_cursor                   | 控制隐式游标状态兼容行为。设置此项，且兼容O，隐式游标状态（SQL%FOUND、SQL%NOTFOUND、SQL%ISOPNE、SQL%ROWCOUNT）由原先的仅在当前执行的函数有效，拓展到包括本函数调用的子函数有效。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| proc_outparam_override          | 控制存储过程出参的重载行为，打开该参数后，对于存储过程只有out出参部分不同的情况下，也可以正常创建和调用。目前只有gsql与jdbc连接数据库时可以使用该参数，对于其他工具打开该参数连接数据库时无法正常调用带有out的存储过程。 支持带有out出参的函数返回record类型，且out出参正常赋值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| proc_implicit_for_loop_variable | 控制存储过程中FOR_LOOP查询语句行为。设置此项时，在FOR rec IN query LOOP语句中，若rec已经定义，不会复用已经定义的rec变量，而且重新建立一个新的变量。否则，会复用已经定义的rec变量，不会建立新的变量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| allow_procedure_compile_check   | 控制存储过程中select语句和open cursor语句的编译检查。设置此项时，在存储过程中执行select语句、open cursor for语句、cursor%rowtype语句、for rec in语句时，若查询的表不存在，则无法创建存储过程，不支持trigger函数的编译检查，若查询的表存在，则成功创建存储过程。 注意：创建密态函数时，需要将allow_procedure_compile_check关闭。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| char_coerce_compat              | 控制char(n)类型向其它变长字符串类型转换时的行为。不设置该参数时，char(n)类型转换其它变长字符串类型时会省略尾部的空格，设置该参数时，转换时不再省略尾部的空格，并且在转换时如果char(n)类型的长度超过其它变长字符串类型时将会报错。该参数仅在sql_compatibility参数的值为A时生效，并且开启该参数后无论是隐式转换、显式转换还是通过调用text(bpchar)函数转换类型都不再省略尾部空格。 ``` 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) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| truncate_numeric_tail_zero      | numeric显示配置项。不设置此项时，numeric按照默认精度显示。设置此项时，除去to_char(numeric, format)这种显示设置精度的情况，所有输出numeric的场景均会隐藏小数点后的末尾0。例如： ``` 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) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| plsql_security_definer          | 开启此参数后，创建存储过程时默认为定义者权限。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| plpgsql_dependency              | 开启此参数后，创建函数，存储过程，包支持未定义的对象。可以新建成功。可以在GS_DEPENDENCIES和GS_DEPENDENCIES_OBJ查询对应的依赖关系。 开启此参数后，创建PLSQL对象时，会主动维护依赖于该PLSQL对象的OID，不再需要用户手动更新。 以下情况支持建立依赖： 1. 函数头中依赖类型和参数默认值位置出现函数。  2. 包，函数中类型、变量依赖类型。  3. 变量声明、变量赋值依赖其他package中变量。  4. 函数体中，函数调用、赋值语句右值表达式中调用函数A，函数A出入参包含函数B时，函数B不建立依赖。例如functionA(functionB())。仅建立和函数A的依赖。  5. 视图中依赖函数。   以下情况不支持不建立依赖： 1. Schema中类型依赖其他类型。  2. SQL语句中对函数，变量，表，视图的依赖。例如 select id into var1 from table1 join view1 on table1.id = pkg1.var1; table1,view1,pkg1均不记录依赖。  3. 视图中对函数，变量，表，视图的依赖。   注意: 1. 在并发创建PLSQL对象时，如果需要维护的对象间存在竞争关系，可能会造成死锁。  2. 当修改对象在gs_dependencies和gs_dependencies_obj中存在时，不允许进行rename操作。  3. 当函数，存储过程，包依赖同义词时，该同义词必须提前建立，不支持主动维护oid。                                                                                                                                                                                                                                                                                                        |
| disable_rewrite_nesttable       | 开启此参数后，针对pg_type表中tableof类型相关字段的重写会被禁用。即读取pg_type表时，会显示tableof类型实际存储的值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| skip_insert_gs_source           | 开启此参数后，创建PLSQL对象时不再插入dbe_pldeveloper.gs_source表中。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| disable_emptystr2null           | 开启此参数后，关闭所有字符类型默认将空串转换为null功能。包括text、clob、blob、raw、bytea、varchar、nvarchar2、bpchar、char、name、byteawithoutorderwithqualcol、byteawithoutordercol类型。该参数为逃生参数，非必要用户不要自行设置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| select_into_return_null         | 此参数仅在PG兼容模式下生效，开启此参数后，存储过程语句SELECT*select_expressions* INTO \[STRICT\] *target* FROM ... 允许在不指定STRICT并且查询结果为空时给变量赋NULL值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| 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=# 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) ``` 如上，f3被错误的默认值填充。 警告： 该场景下，非默认参数会被错位的默认值填充。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| dynamic_sql_compat              | 开启此参数后，动态语句不会将模板SQL中的同名模板参数视为同一个变量，而是按照顺序依次匹配using子句中的变量值。 注意： - 动态语句执行匿名块语句时调用存储过程的场景，只针对IN参数进行矫正，如果需要对OUT参数进行检查需要设置proc_outparam_override选项。  - 动态语句执行匿名块语句时调用存储过程的场景，开启参数后不会对存储过程中参数的IN/OUT属性和using子句中的IN/OUT属性进行检查。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| dynamic_sql_check               | 开启此参数后，动态语句模板SQL中的不同模板参数个数与using子句中的变量个数不同时将会在动态语句执行期间报错。 注意： - 不推荐同时使用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类型仅支持字符类型、数值类型、列名、函数。函数名支持带有schema、包名。不支持参数带有其他子句（如order by子句）、不支持参数为表达式、仅支持参数带有DISTINCT关键字，不支持带有其他关键字时显示完整函数。  - 一些特殊函数不支持投影别名显示完整函数，包括函数：COLLATION FOR、CURRENT_DATE、CURRENT_TIME、CURRENT_TIMESTAMP、DBTIMEZONE、LOCALTIME、LOCALTIMESTAMP、SYSDATE、SESSIONTIMEZONE、ROWNUM、CURRENT_ROLE、CURRENT_USER、SESSION_USER、USER、CURRENT_CATALOG、CURRENT_SCHEMA、CAST、EXTRACT、TIMESTAMPDIFF、OVERLAY、POSITION、SUBSTRING、TREAT、TRIM、NULLIF、NVL、NVL2、COALESCE、GREATEST、LEAST、LNNVL、REGEXP_LIKE以及XML函数。  - 一些安全加解密函数、脱敏函数，投影别名显示完整函数可能存在安全问题，在这里就还是仅显示函数名。包括函数：gs_encrypt_aes128,gs_decrypt_aes128,gs_encrypt,gs_decrypt,aes_encrypt,aes_decrypt,pg_create_physical_replication_slot_extern,dblink_connect,creditcardmasking",basicemailmasking",fullemailmasking,alldigitsmasking,shufflemasking,randommasking,regexpmasking,gs_digest。  - 不支持=\>传参方式调用函数时投影别名显示完整函数，不支持投影别名显示""，如：select "power"(2,3)。  - 为了让投影别名显示完整函数，本功能不受去除末尾0等参数影响。      |
| allow_rownum_alias              | 开启此参数后，将允许ROWNUM在SQL语句中通过AS语法用作列的别名，ROWNUM将作为普通标识符使用，不再能够作为伪列使用。 警告： 不建议在执行业务期间变更该参数的状态。开启参数的状态下，在数据库中用ROWNUM作为名称创建的数据库对象（如表名，列名，数据库名等）只能在开启参数的情况下使用，否则将会产生歧义，行为不可预期。关闭参数的状态下，在数据库中ROWNUM作为伪列使用的行为将在开启参数后失效，行为不可预期。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| current_sysdate                 | 开启此参数后，执行sysdate时，会获取当前操作系统时间。 gaussdb=# set behavior_compat_options='current_sysdate'; SET gaussdb=# select sysdate; current_sysdate --------------------- 2023-06-20 20:15:27 (1 row)                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
   
#### plsql_compile_check_options
**参数说明：**数据库兼容性行为配置项，该参数的值由若干个配置项用逗号隔开构成。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**字符串
**默认值：**""
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表2]。
- 配置多个兼容性配置项时，相邻配置项用逗号隔开，例如：set plsql_compile_check_options='for_loop,outparam';
 
表3兼容性配置项 
| **兼容性配置项**             | **兼容性行为控制**                                                                                                                                                     |
|:---|:---|
| for_loop               | 控制存储过程中FOR_LOOP查询语句行为设置此项时，在FOR rec IN query LOOP语句中，若rec已经定义，不会复用已经定义的rec变量，而且重新建立一个新的变量。否则，会复用已经定义的rec变量，不会建立新的变量。(与proc_implicit_for_loop_variable相同，后续进行收编) |
| outparam               | out重载条件下，有重载函数；将对out出参常量进行检查，禁止out出参为常量报错。                                                                                                                      |
| plsql_expression_check | 编译检查模式开启下，打开当前参数，会额外检查function out出参类型，当out出参无法赋值时，将会报warning提升。                                                                                                |
   
#### a_format_version
**参数说明：**数据库平台兼容性行为配置项，该参数的值为字符串枚举值。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**字符串
**默认值：**""
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表2]。
- 兼容性配置项时设置字符串，例如：set a_format_version='10c';
 
表4兼容性配置项 
| **兼容性配置项** | **兼容性行为控制** |
|:---|:---|
| 10c        | A平台兼容版本     |
   
#### a_format_dev_version
**参数说明：**数据库平台迭代小版本兼容性行为配置项，该参数的值为字符串枚举值。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**字符串
**默认值：**""
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表5]。
- 兼容性配置项时设置字符串，例如：set a_format_dev_version='s1';
 
 表5兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|
| s1         | - A平台兼容迭代小版本，影响函数（TRUNC(date, fmt),ROUND(date, fmt),NVL2,LPAD,RPAD,ADD_MONTHS,MONTHS_BETWEEN,REGEXP_REPLACE,REGEXP_COUNT,TREAT,EMPTY_CLOB,INSTRB,trunc(number),greatest,least,mod,round(number),cast,to_date,to_timestamp,chr,rtrim,translate,to_char,to_number，to_timestamp_tz）。  - 数据类型转换：小数字符串转换成整数类型（int1/int2/int4/int8/int16）时进行四舍五入。  - 数据类型转换：支持timestamp with time zone到timestamp without time zone的隐式转换。   |
| 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）。  - 兼容配置项为s1时的所有行为。                                                                                                                                                                                |
   
#### plpgsql.variable_conflict
**参数说明**：设置同名的存储过程变量和表的列的使用优先级。
该参数属于USERSET类型参数，仅支持[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法3进行设置。
**取值范围**：字符串
- error表示遇到存储过程变量和表的列名同名则编译报错。
- use_variable表示存储过程变量和表的列名同名则优先使用变量。
- use_column表示存储过程变量和表的列名同名则优先使用列名。
**默认值**：error
#### td_compatible_truncation
**参数说明：**控制是否开启与Teradata数据库相应兼容的特征。该参数在用户连接上与TD兼容的数据库时，可以将参数设置成为on（即超长字符串自动截断功能启用），该功能启用后，在后续的insert语句中，对目标表中char和varchar类型的列插入超长字符串时，会按照目标表中相应列定义的最大长度对超长字符串进行自动截断。保证数据都能插入目标表中，而不是报错。
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
超长字符串自动截断功能不适用于insert语句包含外表的场景。
如果向字符集为字节类型编码（SQL_ASCII、LATIN1等）的数据库中插入多字节字符数据（如汉字等），且字符数据跨越截断位置，这种情况下，按照字节长度自动截断，自动截断后会在尾部产生非预期结果。如果用户有对于截断结果正确性的要求，建议用户采用UTF8等能够按照字符截断的输入字符集作为数据库的编码集。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示启动超长字符串自动截断功能。
- off表示停止超长字符串自动截断功能。
**默认值：**off
#### uppercase_attribute_name
**参数说明**：设置列名以大写形式返回给客户端。该参数仅限于ORA兼容模式和集中式环境下使用。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示开启列名以大写形式返回给客户端。
- off表示关闭列名以大写形式返回给客户端。
**默认值**：off
#### lastval_supported
**参数说明：**控制是否可以使用lastval函数。
该参数属于POSTMASTER类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。
**取值范围：**布尔型
- on表示支持lastval函数，同时nextval函数不支持下推。
- off表示不支持lastval函数，同时nextval函数可以下推。
**默认值：**off
#### a_format_copy_version
参数说明：数据库平台迭代小版本兼容性行为配置项，该参数的值为字符串枚举值。
该参数属于USERSET类型参数，请参考[表1](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/gaussdb-12-1496.html#ZH-CN_TOPIC_0000002235341069__zh-cn_topic_0000001581993740_zh-cn_topic_0289899927_zh-cn_topic_0283137176_zh-cn_topic_0237121562_zh-cn_topic_0059777490_t91a6f212010f4503b24d7943aed6d846)中对应设置方法进行设置。使用gs_loader导入工具新特性时，需要设置对应的值。
取值范围：字符串
默认值：''
![](https://support.huaweicloud.com/centralized-devg-v3-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 当前只支持[表6].。
- 兼容性配置项时设置字符串，具体参见《工具参考》的"客户端工具 \> gs_loader"章节，使用方式为通过guc_param设置a_format_copy_version参数。
 
 表6兼容性配置项 
| **兼容性配置项** | **兼容性行为控制**                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
|:---|:---|
| s1         | - 支持gs_loader指定数据类型（CHAR\[(length)\]/INTEGER external\[(length)\]/FLOAT external\[(length)\]/DECIMAL external\[(length)\]/TIMESTAMP/DATE/DATE EXTERNAL/INTEGER/SMALLINT/RAW\[(length)\]）导入数据。  - 支持gs_loader列表达式使用场景扩展。   |
   
