
# GUC使用说明
数据库提供了许多GUC参数，配置这些参数可以影响数据库系统的行为。在修改这些参数时请确保用户理解了这些参数本身的规格限制与修改后对数据库的影响，否则可能会导致无法预料的结果：
- 数据库内部部分参数与环境有关，在数据库安装时便已指定，不建议进行修改。如果有一定要修改的场景，设置时必须确保内容、格式正确，否则会导致实例异常。例如：设置侦听地址的参数listen_addresses；设置端口的参数port；设置ip地址的参数local_bind_address；以及各类设置文件输出路径的参数。

- 受限于使用的硬件资源大小，需要谨慎修改的参数。例如：内存、连接数、影响磁盘空间占用的相关参数。用户修改前需确认使用的硬件规格，确保参数修改后，不会超出硬件本身的大小限制，否则可能会使数据库实例申请不到足够的资源，导致实例状态异常。
- 受限于参数之间的联动，修改参数时需要详细阅读参数对应规格限制。例如：max_wal_senders参数取值必须小于max_connections参数取值，数据库才能正常启动。
- 参数设置不能过于极端，设置过大过小都有使业务受损的可能，需要详细理解参数含义并谨慎修改。例如：session_timeout参数设置1秒，业务与服务器建立连接后，1秒不进行操作，便会断开连接，从而影响业务正常执行。log_min_messages控制打印日志的级别，设置级别过低，会导致记录日志量过大，影响性能。
#### 注意事项
- 参数中如果取值范围为字符串，此字符串应遵循操作系统的路径和文件名命名规则。
- 取值范围最大值为INT_MAX的参数，此选项最大值跟所在的操作系统有关。
- 取值范围最大值为DBL_MAX的参数，此选项最大值跟所在的操作系统有关。
- 部分GUC参数会影响函数/操作符的选择、存储过程的编译以及执行计划的生成，从而会影响到视图、函数参数默认值、存储过程编译产物、计划缓存的行为。由于这些机制原因，后续GUC参数变更可能不会再影响这些行为。
  - 视图：数据库在视图定义时会根据当前GUC参数状态生成重写规则，后续对视图操作时直接使用对应重写规则而不再受GUC参数（会影响重写规则生成的参数）的影响。
  
  - 函数参数默认值：如果函数参数默认值使用了函数，数据库在创建该函数时会根据当前GUC参数状态为默认值参数选择对应的函数并记录选中的函数oid到对应系统表中（pg_proc），后续执行该函数时会使用系统表中记录的函数oid给默认值参数赋值而不再受GUC参数的影响。
  
  - 存储过程编译产物：数据库对存储过程进行编译时会根据当前GUC参数状态生成编译产物，执行存储过程时直接使用编译产物而不再受GUC参数（会影响编译产物生成的参数）的影响。
  
  - 计划缓存：数据库在执行SQL时会根据当前GUC参数状态生成对应的执行计划，如果将该计划缓存起来后，后续再执行该SQL将直接使用该计划而不再受GUC参数（会影响执行计划生成的参数）的影响。
  
  
  有影响GUC参数如下表（GUC参数具体功能详见对应GUC参数）：
  
  | GUC参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 打开参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   | 关闭参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 影响点                                     | 示例                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  |:---|:---|:---|:---|:---|
  | convert_string_to_digit                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 优先将字符串转为数字。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 不支持打开参数时优先将字符串转为数字的行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` CREATE or REPLACE FUNCTION test(c numeric) RETURN text package AS BEGIN RETURN 'test(c numeric)'; END; / CREATE or REPLACE FUNCTION test(c varchar2) RETURN text package AS BEGIN RETURN 'test(c varchar2)'; END; / SET convert_string_to_digit=on; CREATE or REPLACE VIEW test_view AS SELECT test('123'::text); SELECT test('123'::text); test ----------------- test(c numeric) (1 row) SELECT * FROM test_view; test ----------------- test(c numeric) (1 row) --关闭参数 SET convert_string_to_digit=off; SELECT test('123'::text); test ------------------ test(c varchar2) (1 row) --视图行为和直接调用函数行为不一致 SELECT * FROM test_view; test ----------------- test(c numeric) (1 row)) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | set behavior_compat_options = 'current_sysdate';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | SYSDATE函数获取当前操作系统时间（底层使用current_sysdate函数）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | SYSDATE函数获取当前数据库时间（底层使用sysdate函数）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` SET behavior_compat_options = 'current_sysdate'; CREATE or REPLACE VIEW test_view_SYSDATE AS SELECT SYSDATE AS test; SELECT * FROM test_view_SYSDATE;--返回当前操作系统时间 SELECT SYSDATE;--返回当前操作系统时间 --关闭参数 SET behavior_compat_options = ''; --视图行为和直接调用函数行为不一致 SELECT * FROM test_view_SYSDATE;--返回当前操作系统时间 SELECT SYSDATE;--返回当前数据库时间 ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | set a_format_version='10c'; set a_format_dev_version='s1';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | - 新增支持NVL2。  - 新增部分系统函数。  - case when返回类型有变更。  - 集合类型构造器优先级高于函数。  - 支持timestamp到timestamptz的隐式转换。                                                                                                                                                                                   | 不支持打开参数时功能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` SET a_format_version='10c'; SET a_format_dev_version='s1'; CREATE OR REPLACE VIEW test_view_nvl2 AS SELECT nvl2(1,2,3) AS test; SELECT * FROM test_view_nvl2; test ------ 2 (1 row) RESET a_format_dev_version; SELECT * FROM test_view_nvl2; test ------ 2 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
  | set a_format_version='10c'; set a_format_dev_version='s2';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | - 新增支持CURRENT_TIMESTAMP '(' FCONST ')'。  - 新增支持DBTIMEZONE。  - 新增支持LNNVL。  - CURRENT_DATE（a_format_date_timestamp =off 情况下）：返回日期+时间（timestamp）。  - 新增部分系统函数。                                                                                                                                   | 不支持打开参数时功能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` SET a_format_version='10c'; SET a_format_dev_version='s2'; CREATE or REPLACE VIEW test_view_LNNVL AS SELECT LNNVL(123=123) AS test; SELECT * FROM test_view_LNNVL; RESET a_format_dev_version; SELECT * FROM test_view_LNNVL; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | set a_format_version='10c'; set a_format_dev_version='s4';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 新增部分系统函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 不支持打开参数时功能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | set a_format_version='10c'; set a_format_dev_version='s5';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | - 新增部分系统函数。  - 复合类型构造器优先级高于函数。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 不支持打开参数时功能。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` --复合类型构造器优先级高于函数： CREATE TYPE tt AS  ( val1 int, val2 int ); CREATE OR REPLACE FUNCTION tt(va int, vb int) RETURN int IS ret int; BEGIN ret := va; RETURN ret; END; / SET a_format_version='10c'; SET a_format_dev_version='s5'; --赋值给tt变量 CREATE OR REPLACE FUNCTION test0 RETURN int IS va  tt; ret int; BEGIN va := tt(1,2); RAISE INFO 'tt: %' ,va; ret := 9; RETURN ret; END; / SELECT test0(); INFO:  tt: (1,2) test0 ------- 9 (1 row) SET a_format_version=''; SET a_format_dev_version=''; SELECT test0(); INFO:  tt: (1,2) test0 ------- 9 (1 row) --赋值给tt变量 CREATE OR REPLACE FUNCTION test0 RETURN int IS va  tt; ret int; BEGIN va := tt(1,2); RAISE INFO 'tt: %' ,va; ret := 9; RETURN ret; END; / select test0(); ERROR:  cannot assign non-composite value to a row variable ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | set behavior_compat_options = 'enable_bpcharlikebpchar_compare';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 启用bpcharlikebpchar和bpcharnlikebpchar操作符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 关闭bpcharlikebpchar和bpcharnlikebpchar操作符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 视图、存储过程编译产物、计划缓存。                       | ``` CREATE TABLE op_test ( col BPCHAR(2) DEFAULT NULL ); CREATE INDEX op_index ON op_test(col); INSERT INTO op_test VALUES ('a'); INSERT INTO op_test VALUES ('1'); INSERT INTO op_test VALUES ('11'); INSERT INTO op_test VALUES ('12'); INSERT INTO op_test VALUES ('sd'); INSERT INTO op_test VALUES ('aa'); SET behavior_compat_options = 'enable_bpcharlikebpchar_compare'; EXPLAIN (COSTS OFF) SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; QUERY PLAN ------------------------------ Sort Sort Key: col ->  Seq Scan on op_test Filter: (col ~~ col) (4 rows) CREATE OR REPLACE VIEW test_view_bpchar AS SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; EXPLAIN SELECT * FROM test_view_bpchar; QUERY PLAN ---------------------------------------------------------------- Sort  (cost=34.48..34.50 rows=10 width=12) Sort Key: op_test.col ->  Seq Scan on op_test  (cost=0.00..34.31 rows=10 width=12) Filter: (col ~~ col) (4 rows) SET behavior_compat_options = ''; EXPLAIN (COSTS OFF) SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; QUERY PLAN -------------------------------------- Sort Sort Key: col ->  Seq Scan on op_test Filter: (col ~~ (col)::text) (4 rows) EXPLAIN SELECT * FROM test_view_bpchar; QUERY PLAN ---------------------------------------------------------------- Sort  (cost=34.48..34.50 rows=10 width=12) Sort Key: op_test.col ->  Seq Scan on op_test  (cost=0.00..34.31 rows=10 width=12) Filter: (col OPERATOR(pg_catalog.~~) col) (4 rows) --关闭开关的情况下重新创建视图： CREATE OR REPLACE VIEW test_view_bpchar AS SELECT * FROM op_test WHERE col LIKE col::BPCHAR ORDER BY col; explain select * from test_view_bpchar; QUERY PLAN ---------------------------------------------------------------- Sort  (cost=39.34..39.37 rows=10 width=12) Sort Key: op_test.col ->  Seq Scan on op_test  (cost=0.00..39.17 rows=10 width=12) Filter: (col ~~ (col)::text) (4 rows) ``` |
  | set b_format_version='5.7'; set b_format_dev_version='s1';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | - CURDATE、CURRENT_TIME、CURRENT_TIMESTAMP、LOCALTIME、LOCALTIMESTAMP NOW返回语句执行时刻时间戳。  - SYSDATE返回函数执行时刻时间戳。  - DB_JSOBJ、LAST_DAY_FUNC、EXTRACT、TIMESTAMPDIFF、SUBSTRING函数行为变更为与MYSQL一致。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | - CURDATE、CURRENT_TIME、CURRENT_TIMESTAMP、LOCALTIME、LOCALTIMESTAMP NOW、SYSDATE函数返回事务开始时刻时间戳。  - DB_JSOBJ、LAST_DAY_FUNC、EXTRACT、TIMESTAMPDIFF、SUBSTRING函数恢复默认行为。   | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | set behavior_compat_options = 'bind_procedure_searchpath';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | - 未指定模式名的存储过程中的数据库对象的搜索路径配置项。  - 在存储过程中如果不显示指定模式名，会优先在存储过程所属的模式下搜索。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 存储过程编译产物。                               | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | set behavior_compat_options = 'proc_outparam_override';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 控制存储过程出参的重载行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 存储过程编译产物。                               | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | enable_bitmapscan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | scan算子选择bitmapscan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | scan算子不选择bitmapscan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 计划缓存。                                   | ``` SET enable_auto_explain=true; SET auto_explain_level=notice; CREATE TABLE t1( a int, b int, c int,d varchar)WITH(storage_type=ustore); CREATE TABLE t2( a int, b int, c int,d varchar)WITH(storage_type=ustore); INSERT INTO t1 SELECT i,10*random()*i,i%20,'atr'||i from generate_series(1,1000) i; CREATE INDEX index1 ON t1(a); SET enable_bitmapscan=on; SET enable_seqscan=off; SET enable_indexscan=off; CREATE OR REPLACE PROCEDURE proc_while_loop() AS DECLARE i int :=1; BEGIN WHILE i < 5 LOOP INSERT INTO t2 SELECT * FROM t1 WHERE a = i ; i:=i+1; END LOOP; END; / CALL proc_while_loop(); SET enable_bitmapscan=off; CALL proc_while_loop(); SET enable_bitmapscan=on; CALL proc_while_loop(); ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | enable_indexscan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | scan算子选择indexscan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | scan算子不选择indexscan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 计划缓存。                                   | ``` SET enable_auto_explain=true; SET auto_explain_level=notice; CREATE TABLE t1( a int, b int, c int,d varchar)WITH(storage_type=ustore); CREATE TABLE t2( a int, b int, c int,d varchar)WITH(storage_type=ustore); INSERT INTO t1 SELECT i,10*random()*i,i%20,'atr'||i from generate_series(1,1000) i; CREATE INDEX index1 on t1(a); SET enable_bitmapscan=off; SET enable_seqscan=off; CREATE OR REPLACE PROCEDURE proc_while_loop() AS DECLARE i int :=1; BEGIN WHILE i < 5 LOOP insert into t2 select * from t1 where a = i ; i:=i+1; END LOOP; END; / CALL proc_while_loop(); SET enable_indexscan=off; CALL proc_while_loop(); ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | query_Dop                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 用户自定义的查询并行度。开启SMP功能，系统会使用设定的并行度执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 默认值为1，1表示关闭并行查询。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 计划缓存。                                   | ``` SET enable_auto_explain=true; SET auto_explain_level=notice; CREATE TABLE t1( a int, b int, c int,d varchar)WITH(storage_type=ustore); CREATE TABLE t2( a int, b int, c int,d varchar)WITH(storage_type=ustore); INSERT INTO t1 SELECT i,10*random()*i,i%20,'atr'||i from generate_series(1,1000) i; CREATE INDEX index1 ON t1(a); SET enable_bitmapscan=f; CREATE OR REPLACE PROCEDURE proc_while_loop() AS DECLARE i int :=1; BEGIN WHILE i < 5 LOOP INSERT INTO t2 SELECT /*+ indexscan(t1 index1) */* FROM t1 WHERE a = i ; i:=i+1; END LOOP; END; / SET enable_auto_explain=true; SET auto_explain_level=notice; SET client_min_messages=log; SET query_dop=4; SET sql_beta_feature='enable_plsql_smp'; CALL proc_while_loop(); SET enable_force_Smp=on; CALL proc_while_loop(); SET query_Dop=6; CALL proc_while_loop(); ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
  | set plan_cache_mode = force_generic_plan                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | pbe情况下，强制执行gplan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | pbe情况下，不强制执行gplan。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 计划缓存。                                   | ``` SET enable_auto_explain=true; SET auto_explain_level=notice; CREATE TABLE t1( a int, b int, c int,d varchar)WITH(storage_type=ustore); CREATE TABLE t2( a int, b int, c int,d varchar)WITH(storage_type=ustore); INSERT INTO t1 SELECT i,10*random()*i,i%20,'atr'||i from generate_series(1,1000) i; CREATE INDEX index1 ON t1(a); SET enable_bitmapscan=on; SET enable_seqscan=off; SET enable_indexscan=off; CREATE OR REPLACE PROCEDURE proc_while_loop() AS DECLARE i int :=1; BEGIN WHILE i < 5 LOOP insert into t2 select * from t1 where a = i ; i:=i+1; END LOOP; END; / CALL proc_while_loop(); SET plan_cache_mode = force_generic_plan; PREPARE aa AS SELECT proc_while_loop(); EXECUTE aa; SET enable_bitmapscan=off; EXECUTE aa; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | a_format_date_timestamp                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | CURRENT_DATE返回当前SQL启动的时间戳。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             | CURRENT_DATE返回事务开启的日期或日期及时间。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 视图、函数参数默认值、存储过程编译产物、计划缓存。               | ``` SET a_format_date_timestamp=on; CREATE OR REPLACE PROCEDURE proc_while_loop() AS DECLARE i date; BEGIN i:=current_date; raise info 'step2:%',TO_CHAR(current_date, 'MM-DD-YYYY HH24:MI:SS'); END; / CALL proc_while_loop(); PREPARE p1 AS SELECT current_timestamp; EXECUTE p1; SET a_format_date_timestamp=off; CALL proc_while_loop(); EXECUTE p1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  | proc_implicit_for_loop_variable                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 控制存储过程中FOR_LOOP查询语句行为设置此项时，在FOR rec IN query LOOP语句中，若rec已经定义，不会复用已经定义的rec变量，而是会重新建立一个新的变量。否则，会复用已经定义的rec变量，不会建立新的变量。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 存储过程编译产物。                               | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | adjust_systemview_priority                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 同名视图优先访问用户自定义视图。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 同名视图优先访问系统视图。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | 视图参数默认值。                                | ``` CREATE DATABASE database_test DBCOMPATIBILITY = 'A'; SELECT datname,datcompatibility,dattimezone FROM pg_database; \c database_test CREATE TABLE t1(c int); CREATE VIEW dual AS SELECT * FROM t1; SET adjust_systemview_priority = off; SELECT * FROM dual; PREPARE p1 as SELECT * FROM dual; EXECUTE p1; SET adjust_systemview_priority = on; SELECT * FROM dual; EXECUTE p1; ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
  | set behavior_compat_options = 'enable_ora_joinop_in_updatestmt';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | update语法中，在set子句"="后面加子查询，且子查询中使用"(+)"操作符，此时"(+)"表示外连接。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | update语法中，在set子句"="后面加子查询，且子查询中使用"(+)"操作符，此时"(+)"没有实际作用。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | update语句中set子句附带子查询时，子查询中"(+)"操作符是否起作用。 | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | m_format_behavior_compat_options中的部分兼容性配置项： - enable_escape_string  - select_column_name  - cast_as_new_json  - enable_samename_funcs  - grant_database_nomapping  - forbid_none_space_comment  - enable_load_data_remote_transmission   | 影响M-Compatibility模式的部分特性兼容性行为，具体打开参数的影响见[表2](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-40-0365.html#ZH-CN_TOPIC_0000002558948779__zh-cn_topic_0000002558217845_zh-cn_topic_0000002372412317_table144781572810)说明。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 影响M-Compatibility模式的部分特性兼容性行为，具体关闭参数的影响见[表2](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-40-0365.html#ZH-CN_TOPIC_0000002558948779__zh-cn_topic_0000002558217845_zh-cn_topic_0000002372412317_table144781572810)说明。                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 计划缓存。                                   | ``` -- enable_escape_string选项变化，不会让计划重新生成。 m_db=# SET m_format_behavior_compat_options=''; SET m_db=# PREPARE p1 FROM "select '1\t2'"; PREPARE m_db=# EXECUTE p1; ?column? ---------- 1\t2 (1 row) m_db=# SET m_format_behavior_compat_options='enable_escape_string'; SET m_db=# EXECUTE p1; ?column? ---------- 1\t2 (1 row) -- select_column_name选项变化，不会让计划重新生成。 m_db=# SET m_format_behavior_compat_options=''; SET m_db=# PREPARE p2 from "select '1'"; PREPARE m_db=# EXECUTE p2; ?column? ---------- 1 (1 row) m_db=# SET m_format_behavior_compat_options='select_column_name'; SET m_db=# EXECUTE p2; ?column? ---------- 1 (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
  | disable_keyword_options                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        | 影响各兼容模式关键字的行为，具体内容可参考[表12](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-40-0365.html#ZH-CN_TOPIC_0000002558948779__zh-cn_topic_0000002558217845_zh-cn_topic_0000002372412317_table11486145314219)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 影响各兼容模式关键字的行为，具体内容可参考[表12](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-40-0365.html#ZH-CN_TOPIC_0000002558948779__zh-cn_topic_0000002558217845_zh-cn_topic_0000002372412317_table11486145314219)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 计划缓存。                                   | ``` gaussdb=# SET disable_keyword_options = 'dbtimezone'; SET gaussdb=# PREPARE p1 AS SELECT 1 dbtimezone; PREPARE gaussdb=# EXECUTE p1; dbtimezone ------------ 1 (1 row) gaussdb=# SET disable_keyword_options = ''; SET gaussdb=# EXECUTE p1; dbtimezone ------------ 1 (1 row) gaussdb=# DEALLOCATE p1; DEALLOCATE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
  | backslash_quote                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 打开参数允许字符串文本中的单引号使用\\'表示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 关闭参数不允许字符串文本中的单引号使用\\'表示。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | 计划缓存。                                   | ``` gaussdb=# SET backslash_quote = 'safe_encoding'; SET gaussdb=# PREPARE p1 AS SELECT text E'Don \'t do that.'; PREPARE gaussdb=# EXECUTE p1; text ----------------- Don 't do that. (1 row) gaussdb=# SET backslash_quote = off; SET gaussdb=# EXECUTE p1; text ----------------- Don 't do that. (1 row) gaussdb=# DEALLOCATE p1; DEALLOCATE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
  | set m_format_dev_version = 's1'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | - 禁用SELECT FETCH FIRST ROWS ONLY语法。  - 禁用TRUNCATE CASCADE/RESTRICT语法。  - 禁用CREATE TABLE中定义主键时指定USING INDEX TABLESPACE tablespace_name语法。  - DROP TABLE/VIEW/COLUMN中CASCADE/RESTRICT语法语义改变，改为忽略CASCADE/RESTRICT的语义，且默认行为为RESTRICT。  - CREATE TABLE REFERENCES作为列约束时，语法语义改变，改为忽略该外键定义。   | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 计划缓存。                                   | ``` -- m_format_dev_version选项变化，不会让计划重新生成。 m_db=# CREATE TABLE t1(a INT); CREATE TABLE m_db=# SET m_format_dev_version = ''; SET m_db=# PREPARE P1 FROM "SELECT * FROM t1 FETCH FIRST ROWS ONLY;"; PREPARE m_db=# EXECUTE P1; a --- (0 rows) m_db=# SET m_format_dev_version = 's1'; SET m_db=# EXECUTE P1; a --- (0 rows) m_db=# DROP TABLE t1; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
  | set m_format_dev_version = 's2'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 影响M-Compatibility模式的部分特性兼容性行为，具体打开参数的影响见[m_format_dev_version](https://support.huaweicloud.com/centralized-devg-v8-gaussdb/gaussdb-40-0365.html#ZH-CN_TOPIC_0000002558948779__zh-cn_topic_0000002558217845_zh-cn_topic_0000002372412317_section1075344362218)说明。 其中以下行为在m_format_dev_version选项变化后，不会让计划重新生成： 创建生成列不指定STORED和VIRTUAL关键字，默认创建虚拟生成列。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 计划缓存。                                   | ``` -- m_format_dev_version选项变化，不会让计划重新生成。 m_db=# SET m_format_dev_version = ''; SET m_db=# PREPARE p1 FROM "CREATE TABLE tgen (a INT, b INT GENERATED ALWAYS AS (1))"; PREPARE m_db=# EXECUTE P1; CREATE TABLE m_db=# DESC tgen; Field |  Type   | Null | Key | Default |      Extra -------+---------+------+-----+---------+------------------ a     | integer | YES  |     |         | b     | integer | YES  |     |         | STORED GENERATED (2 rows) m_db=# DROP TABLE tgen; DROP TABLE m_db=# SET m_format_dev_version = 's2'; SET m_db=# EXECUTE P1; CREATE TABLE m_db=# DESC tgen; Field |  Type   | Null | Key | Default |      Extra -------+---------+------+-----+---------+------------------ a     | integer | YES  |     |         | b     | integer | YES  |     |         | STORED GENERATED (2 rows) m_db=# DROP TABLE tgen; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
  | set sql_mode='ansi_quotes'                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | M-Compatibility模式下标识符同时支持反引号（\`\`）和双引号（""）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            | M-Compatibility模式下标识符仅支持反引号(\`\`)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 计划缓存。                                   | ``` -- sql_mode选项变化，不会让计划重新生成。 m_db=# CREATE TABLE t1(a int); CREATE TABLE m_db=# SET sql_mode = 'ansi_quotes'; SET m_db=# PREPARE p1 FROM 'INSERT INTO "t1" VALUES(1)'; PREPARE m_db=# EXECUTE p1; INSERT 0 1 m_db=# SET sql_mode=''; SET m_db=# EXECUTE p1; INSERT 0 1 m_db=# DROP TABLE t1; DROP TABLE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
  | standard_conforming_strings                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 按照SQL标准把反斜杠当做普通文本。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 反斜杠在字符串字面值中被解释为转义字符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    | 计划缓存。                                   | ``` gaussdb=# SET standard_conforming_strings = on; SET gaussdb=# PREPARE p1 AS SELECT u&'d\0061t\+000061' AS u&"d\0061t\+000061"; PREPARE gaussdb=# SELECT u&'d\0061t\+000061' AS u&"d\0061t\+000061"; data ------ data (1 row) gaussdb=# EXECUTE p1; data ------ data (1 row) gaussdb=# SET standard_conforming_strings = off; SET gaussdb=# SELECT u&'d\0061t\+000061' AS u&"d\0061t\+000061"; ERROR:  unsafe use of string constant with Unicode escapes LINE 1: select u&'d\0061t\+000061' as u&"d\0061t\+000061"; ^ DETAIL:  String constants with Unicode escapes cannot be used when standard_conforming_strings is off. gaussdb=# EXECUTE p1; data ------ data (1 row) gaussdb=# DEALLOCATE p1; DEALLOCATE ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
  | character_set_connection和collation_connection                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 设置常量字符串的字符集和字符序。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | 恢复默认行为。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 计划缓存。                                   | ``` -- collation_connection参数变化，计划不会重新生成 m_db=# prepare p1 from "select 'a' = 'A'"; PREPARE m_db=# execute p1; ?column? ---------- t (1 row) m_db=# set collation_connection = utf8mb4_bin; SET m_db=# execute p1; ?column? ---------- t (1 row) m_db=# select 'a' = 'A'; ?column? ---------- f (1 row) -- character_set_connection参数变化，计划不会重新生成 m_db=# prepare p1 from "select 'a' = 'A'"; PREPARE m_db=# execute p1; ?column? ---------- t (1 row) m_db=# set character_set_connection = binary; SET m_db=# execute p1; ?column? ---------- t (1 row) m_db=# select 'a' = 'A'; ?column? ---------- f (1 row) ```                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
     
  
 
