# DBE_STATS
高级包DBE_STATS提供了统计信息管理的功能，包括锁定、解锁、回退统计信息和清除历史统计信息等。DBE_STATS支持的接口请参见[表1]。
![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
DBE_STATS不支持临时表。
#### 接口介绍
 表1DBE_STATS 
| 接口名称                                                                                         | 描述                                                              | 权限要求                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|
| [DBE_STATS.LOCK_TABLE_STATS]                 | 锁定表级统计信息。                                                      | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.LOCK_PARTITION_STATS]            | 锁定分区级统计信息。                                                     | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.LOCK_COLUMN_STATS]              | 锁定列级统计信息。                                                      | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.LOCK_SCHEMA_STATS]             | 锁定指定schema下所有表相关的统计信息。                                          | - 调用该接口时，会锁定该schema下所有当前用户有ANALYZE权限的表，对于没有权限的表直接跳过。  - 调用该接口需拥有指定schema的USAGE权限。                                                                                                                                                                                                                                                                                                                                                   |
| [DBE_STATS.UNLOCK_TABLE_STATS]             | 解锁表级统计信息。                                                         | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [DBE_STATS.UNLOCK_PARTITION_STATS]          | 解锁分区级统计信息。                                                      | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [DBE_STATS.UNLOCK_COLUMN_STATS]             | 解锁列级统计信息。                                                       | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| [DBE_STATS.UNLOCK_SCHEMA_STATS]           | 解锁指定schema下所有表相关的统计信息。                                          | - 调用该接口时，会解锁该schema下所有当前用户有ANALYZE权限的表，对于没有权限的表直接跳过。  - 调用该接口需拥有指定schema的USAGE权限。                                                                                                                                                                                                                                                                                                                                                      |
| [DBE_STATS.RESTORE_TABLE_STATS]               | 回退表级统计信息到指定时间点。                                                  | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.RESTORE_PARTITION_STATS]         | 回退分区级统计信息到指定时间点。                                               | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.RESTORE_COLUMN_STATS]           | 回退列级统计信息到指定时间点。                                                 | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.RESTORE_SCHEMA_STATS]            | 回退指定schema下所有表相关的统计信息到指定时间点。                                    | - 调用该接口时，会回退该schema下所有当前用户有ANALYZE权限的表，对于没有权限的表直接跳过。  - 调用该接口需拥有指定schema的USAGE权限。                                                                                                                                                                                                                                                                                                                                                |
| [DBE_STATS.PURGE_STATS]                    | 清除指定时间节点前的所有历史统计信息。                                              | 只有初始用户可调用该接口。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| [DBE_STATS.GET_STATS_HISTORY_RETENTION]  | 获取历史统计信息的保留时间。                                                 | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [DBE_STATS.GET_STATS_HISTORY_AVAILABILITY] | 获取最早可用的历史统计信息的时间。                                                | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| [DBE_STATS.CREATE_STAT_TABLE]            | 创建用于保存统计信息的统计表。                                                 | 要调用此过程创建统计表，需要用户拥有在指定schema与指定tablespace下创建表和创建索引的权限。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| [DBE_STATS.DROP_STAT_TABLE]                 | 删除用于保存统计信息的统计表。                                                   | 要调用此过程删除统计表，需要用户拥有在指定schema下删除表和删除索引的权限。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| [DBE_STATS.EXPORT_INDEX_STATS]           | 检索指定索引的统计信息并存储在用户统计信息表中。                                         | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                             |
| [DBE_STATS.EXPORT_TABLE_STATS]              | 检索指定表的统计信息并存储在用户统计信息表中。                                         | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                             |
| [DBE_STATS.EXPORT_COLUMN_STATS]             | 检索指定列的统计信息并存储在用户统计信息表中。                                        | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                             |
| [DBE_STATS.EXPORT_SCHEMA_STATS]           | 检索指定schema的统计信息并存储在用户统计信息表中。                                     | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                             |
| [DBE_STATS.EXPORT_DATABASE_STATS]          | 用于检索指定database的统计信息，并存储在用户统计信息表中。                              | - 调用该接口时，会导出当前database下所有当前用户有ANALYZE权限的用户表，对于没有权限的表直接跳过。    - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                                                            |
| [DBE_STATS.IMPORT_INDEX_STATS]               | 从用户统计信息表中检索指定索引的统计信息，并将其写回系统表。                                | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息从用户统计信息表导回系统表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                |
| [DBE_STATS.IMPORT_TABLE_STATS]              | 从用户统计信息表中检索指定表的统计信息，并将其写回系统表。                                  | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息从用户统计信息表导回系统表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                |
| [DBE_STATS.IMPORT_COLUMN_STATS]            | 从用户统计信息表中检索指定列的统计信息，并将其写回系统表。                                   | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息从用户统计信息表导回系统表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                |
| [DBE_STATS.IMPORT_SCHEMA_STATS]            | 从用户统计信息表中检索指定schema的统计信息，并将其写回系统表。                              | - 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。  - 调用此过程将统计信息从用户统计信息表导回系统表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                |
| [DBE_STATS.IMPORT_DATABASE_STATS]          | 从用户统计信息表中检索指定database的统计信息，并将其写回系统表。                           | - 调用该接口时，导入当前database下所有当前用户有ANALYZE权限用户表的统计信息，对于没有权限的表直接跳过。  - 调用此过程将统计信息导出到用户统计信息表，需要对用户统计信息表具有SELECT、INSERT、DELETE和UPDATE的权限。                                                                                                                                                                                                                                                                                                 |
| [DBE_STATS.SET_COLUMN_STATS]               | 设置列相关的统计信息，包括单列、多列、表达式统计信息。                                        | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.SET_INDEX_STATS]                 | 设置索引相关的统计信息。                                                  | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.SET_TABLE_STATS]                 | 设置表相关的统计信息。                                                     | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.DELETE_COLUMN_STATS]          | 删除列相关的统计信息，包括单列、多列、表达式统计信息。                                    | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.DELETE_INDEX_STATS]           | 删除索引相关的统计信息。                                                    | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.DELETE_TABLE_STATS]           | 删除表相关的统计信息。                                                     | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.DELETE_SCHEMA_STATS]                | 删除schema下所有表、索引、列相关的统计信息。                                        | 使用该接口时，用户必须对指定的表拥有与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| [DBE_STATS.GET_TABLES_BY_SQLID]             | 获取Unique SQL ID对应语句所有涉及的表，如果含有多张表，则返回多行记录。                     | 使用该接口时，用户的权限需要满足以下其中一种情况： - 用户是初始用户。  - 用户拥有MONADMIN访问权限。                                                                                                                                                                                                                                                                                                                                  |
| [DBE_STATS.ANALYZE_SQLID]                   | 获取Unique SQL ID对应语句所有涉及的表，以及收集对应表的统计信息。对于收集成功的表，如果含有多张表，则返回多行记录。 | 使用该接口时，用户的权限需要满足以下其中一种情况： - 用户是初始用户。  - 用户拥有MONADMIN访问权限，同时拥有相应表与ANALYZE命令相同的权限。有关权限的详细信息，请参见[ANALYZE \| ANALYSE](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-0225.html)。                                                                                                                                                                                   |
| [dbe_stats_tools.py]                      | 用于库级统计信息导出和导入，以及计划调优语句元信息导出。                                    | - 导出统计信息时，需要具备相应的接口或命令（DBE_STATS.CREATE_STAT_TABLE、DBE_STATS.EXPORT_DATABASE_STATS、\\COPY TO、DBE_STATS.DROP_STAT_TABLE）的权限，以及指定导出目录的读写权限。  - 导入统计信息时，需要具备相应接口或命令（DBE_STATS.CREATE_STAT_TABLE、DBE_STATS.EXPORT_DATABASE_STATS、\\COPY FROM、DBE_STATS.DROP_STAT_TABLE）的权限，以及指定导出目录下文件的读取权限。  - 导出语句元信息时，需要数据库的系统管理员权限，以及指定目录的读写权限。   |
   
- DBE_STATS.LOCK_TABLE_STATS
  锁定一个表的统计信息。锁定后，该表的统计信息无法更新，该表下级的索引、分区和列也会同步被锁定。该接口无返回值。
  DBE_STATS.LOCK_TABLE_STATS原型为：
  ```
  DBE_STATS.LOCK_TABLE_STATS(
     ownname   VARCHAR2,
     tabname   VARCHAR2
  );
  ```
  表2DBE_STATS.LOCK_TABLE_STATS接口参数说明 
  | 参数      | 类型        | 是否允许为空 | 描述                                 |
  |:---|:---|:---|:---|
  | ownname | varchar2   | 是     | 要锁定的表所属的schema名称，该参数为空时，默认为当前schema。 |
  | tabname  | varchar2 | 否    | 要锁定的表的名称。                           |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 可以通过查看表的reloptions中的stat_state状态获取该表的锁定状态。
  
  - 当一个表处于锁定状态时，其统计信息无法更新。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表。
  gaussdb=# CREATE SCHEMA dbe_stats_lock;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_lock;
  SET
  gaussdb=# CREATE TABLE t1(a int,b int);
  CREATE TABLE
  -- 锁定表，查看其锁定状态。
  gaussdb=# CALL DBE_STATS.LOCK_TABLE_STATS(ownname=>'dbe_stats_lock',tabname=>'t1');
   lock_table_stats 
  ------------------
  (1 row)
  gaussdb=# SELECT relname,instr(reloptions::text,'stat_state=locked',1,1) <> 0  AS exist_lock FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock');
   relname | exist_lock 
  ---------+------------
   t1      | t
  (1 row)
  -- 锁定后analyze, 发生报错。
  gaussdb=# ANALYZE t1;
  ERROR:  The statistics is locked, cannot be updated.
  -- 删除表、删除命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock;
  DROP SCHEMA
  ```
  
- DBE_STATS.LOCK_PARTITION_STATS
  锁定一个分区的统计信息。锁定后，该分区的统计信息无法更新，该分区下级的索引、分区、列会同步锁定。该接口无返回值。
  DBE_STATS.LOCK_PARTITION_STATS原型为：
  ```
  DBE_STATS.LOCK_PARTITION_STATS(
      ownname     VARCHAR2,
      tabname     VARCHAR2,
      partname    VARCHAR2
  );
  ```
  表3DBE_STATS.LOCK_PARTITION_STATS接口参数说明 
  | 参数        | 类型         | 是否允许为空 | 描述                                    |
  |:---|:---|:---|:---|
  | ownname  | varchar2   | 是      | 要锁定的分区所属的schema名称，该参数为空时，默认为当前schema。 |
  | tabname   | varchar2  | 否     | 要锁定的分区所属的表的名称。                           |
  | partname | varchar2 | 否      | 要锁定的分区的名称。                              |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 可以通过查看该分区的reloptions中的stat_state状态获取该表的锁定状态。
  
  - 当该分区或该表所属的表处于锁定状态时，其统计信息无法更新。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表。
  gaussdb=# CREATE SCHEMA dbe_stats_lock;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_lock;
  SET
  gaussdb=# CREATE TABLE upart_table(a int, b int, c int) PARTITION BY RANGE(a)
   (
      PARTITION p1 VALUES LESS THAN(1200),
      PARTITION p2 VALUES LESS THAN(2400),
      PARTITION p3 VALUES LESS THAN(MAXVALUE)
   );
  CREATE TABLE
  -- 锁定一个分区，其他分区及表不受影响。
  gaussdb=# CALL DBE_STATS.LOCK_PARTITION_STATS(ownname=>'dbe_stats_lock',tabname=>'upart_table',partname=>'p1');
   lock_partition_stats 
  ----------------------
  (1 row)
  gaussdb=# SELECT relname,instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock FROM PG_CLASS WHERE relname='upart_table';
     relname   | exist_lock 
  -------------+------------
   upart_table | f
  (1 row)
  gaussdb=# SELECT relname,instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock FROM PG_PARTITION WHERE parentid='upart_table'::REGCLASS ORDER BY 1;
     relname   | exist_lock
  -------------+------------
   p1          | t
   p2          | f
   p3          | f
   upart_table | f
  (4 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE upart_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock;
  DROP SCHEMA
  ```
  
- DBE_STATS.LOCK_COLUMN_STATS
  锁定一个列的统计信息。锁定后，该列的统计信息无法更新。该接口无返回值。
  DBE_STATS.LOCK_COLUMN_STATS原型为：
  ```
  DBE_STATS.LOCK_COLUMN_STATS(
      ownname     VARCHAR2,
      tabname     VARCHAR2,
      colname     VARCHAR2,
      partname    VARCHAR2 DEFAULT NULL
  );
  ```
  表4DBE_STATS.LOCK_COLUMN_STATS接口参数说明 
  | 参数        | 类型         | 是否允许为空 | 描述                                    |
  |:---|:---|:---|:---|
  | ownname  | varchar2     | 是      | 要锁定的列所属的schema的名称，该参数为空时，默认为当前schema。 |
  | tabname | varchar2   | 否         | 要锁定的列所属的表的名称。                          |
  | colname | varchar2    | 否       | 要锁定的列的名称。                             |
  | partname  | varchar2 | 是       | 要锁定的列所属的分区的名称，默认为空。                      |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 当partname为空时，默认锁定该列表级统计信息。
  
  - 若不存在该表的列级统计信息，则锁定可执行成功，但实际未生效。
  
  - 可查看[PG_STATISTIC](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1257.html)、[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的stastate获取锁定状态。
  
  - 锁定多列时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当某一列被锁定或其所属的表或分区被锁定时，其统计信息无法更新，该列被锁定的信息不会回显，需要在日志中通过DEBUG2级别的DBE_STATS的logging_module查看。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_lock;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_lock;
  SET
  gaussdb=# CREATE TABLE t1(a int,b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(generate_series(1,100),1);
  INSERT 0 100
  gaussdb=# ANALYZE t1;
  ANALYZE
  -- 锁定列后，查看列的锁定状态。
  gaussdb=# CALL DBE_STATS.LOCK_COLUMN_STATS(ownname=>'dbe_stats_lock',tabname=>'t1',colname=>'a');
   lock_column_stats 
  -------------------
  (1 row)
  gaussdb=# SELECT staattnum,stastate FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1,2;
   staattnum | stastate
  -----------+----------
           1 | l
           2 | u
  (2 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock;
  DROP SCHEMA
  ```
  
- DBE_STATS.LOCK_SCHEMA_STATS
  锁定一个指定schema下所有表的统计信息。该接口无返回值。
  DBE_STATS.LOCK_SCHEMA_STATS原型为：
  ```
  DBE_STATS.LOCK_SCHEMA_STATS(
      ownname    VARCHAR2
  );
  ```
  表5DBE_STATS.LOCK_SCHEMA_STATS接口参数说明 
  | 参数    | 类型        | 是否允许为空 | 描述                             |
  |:---|:---|:---|:---|
  | ownname | varchar2 | 是     | 指定的schema名，该参数为空时，默认为当前schema。 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_lock_schema CASCADE;
  NOTICE:  schema "dbe_stats_lock_schema" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表
  gaussdb=# CREATE SCHEMA dbe_stats_lock_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_lock_schema;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# CREATE TABLE t2(a int, b int);
  CREATE TABLE
  gaussdb=# -- 锁定schema
  gaussdb=# CALL DBE_STATS.LOCK_SCHEMA_STATS(ownname=>'dbe_stats_lock_schema');
   lock_schema_stats 
  -------------------
  (1 row)
  gaussdb=# -- 验证: t1和t2都应被锁定 (exist_lock = t)
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_CLASS
  gaussdb-# WHERE relname IN ('t1','t2')
  gaussdb-#   AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock_schema')
  gaussdb-# ORDER BY 1;
   relname | exist_lock 
  ---------+------------
   t1      | t
   t2      | t
  (2 rows)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock_schema;
  DROP SCHEMA
  ```
  
- DBE_STATS.UNLOCK_TABLE_STATS
  解锁一个表的统计信息。解锁后，该表的统计信息可以更新。该表下级的索引、分区、列会同步解锁。该接口无返回值。
  DBE_STATS.UNLOCK_TABLE_STATS原型为：
  ```
  DBE_STATS.UNLOCK_TABLE_STATS(
     ownname   VARCHAR2,
     tabname   VARCHAR2
  );
  ```
  表6DBE_STATS.UNLOCK_TABLE_STATS接口参数说明 
  | 参数        | 类型        | 是否允许为空 | 描述                                  |
  |:---|:---|:---|:---|
  | ownname | varchar2    | 是       | 要解锁的表所属的schema的名称，该参数为空时，默认为当前schema。 |
  | tabname  | varchar2 | 否        | 要解锁的表的名称。                            |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 可以通过查看该表的reloptions中的stat_state状态获取该表的锁定状态。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_lock_unlock_table CASCADE;
  NOTICE:  schema "dbe_stats_lock_unlock_table" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表
  gaussdb=# CREATE SCHEMA dbe_stats_lock_unlock_table;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_lock_unlock_table;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# -- 先锁定表
  gaussdb=# CALL DBE_STATS.LOCK_TABLE_STATS(ownname=>'dbe_stats_lock_unlock_table', tabname=>'t1');
   lock_table_stats 
  ------------------
  (1 row)
  gaussdb=# -- 验证已锁定
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_CLASS
  gaussdb-# WHERE relname='t1'
  gaussdb-#   AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock_unlock_table');
   relname | exist_lock 
  ---------+------------
   t1      | t
  (1 row)
  gaussdb=# -- 解锁表
  gaussdb=# CALL DBE_STATS.UNLOCK_TABLE_STATS(ownname=>'dbe_stats_lock_unlock_table', tabname=>'t1');
   unlock_table_stats 
  --------------------
  (1 row)
  gaussdb=# -- 验证已解锁 (exist_lock = f)
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_CLASS
  gaussdb-# WHERE relname='t1'
  gaussdb-#   AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock_unlock_table');
   relname | exist_lock 
  ---------+------------
   t1      | f
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock_unlock_table;
  DROP SCHEMA
  ```
  
- DBE_STATS.UNLOCK_PARTITION_STATS
  解锁一个分区的统计信息。解锁后，该分区的统计信息可以更新。该分区下级的索引、分区、列会同步解锁。该接口无返回值。
  DBE_STATS.UNLOCK_PARTITION_STATS原型为：
  ```
  DBE_STATS.UNLOCK_PARTITION_STATS(
      ownname     VARCHAR2,
      tabname     VARCHAR2,
      partname    VARCHAR2
  );
  ```
  表7DBE_STATS.UNLOCK_PARTITION_STATS接口参数说明 
  | 参数      | 类型        | 是否允许为空 | 描述                                      |
  |:---|:---|:---|:---|
  | ownname | varchar2  | 是     | 要解锁的分区所属的schema的名称，该参数为空时，默认为当前schema。 |
  | tabname | varchar2 | 否       | 要解锁的分区所属的表的名称。                         |
  | partname | varchar2   | 否    | 要解锁的分区的名称。                             |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 可查看该分区的reloptions中stat_state状态获取该表的锁定状态。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_lock_unlock_partition CASCADE;
  NOTICE:  schema "dbe_stats_lock_unlock_partition" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建分区表
  gaussdb=# CREATE SCHEMA dbe_stats_lock_unlock_partition;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_lock_unlock_partition;
  SET
  gaussdb=# CREATE TABLE upart_table(a int, b int, c int) PARTITION BY RANGE(a)
  gaussdb-# (
  gaussdb,
  gaussdb,
  gaussdb
  gaussdb;
  CREATE TABLE
  gaussdb=# -- 先锁定p1
  gaussdb=# CALL DBE_STATS.LOCK_PARTITION_STATS(ownname=>'dbe_stats_lock_unlock_partition', tabname=>'upart_table', partname=>'p1');
   lock_partition_stats 
  ----------------------
  (1 row)
  gaussdb=# -- 验证p1已锁定
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_PARTITION
  gaussdb-# WHERE parentid='upart_table'::REGCLASS
  gaussdb-# ORDER BY 1;
     relname   | exist_lock 
  -------------+------------
   p1          | t
   p2          | f
   p3          | f
   upart_table | f
  (4 rows)
  gaussdb=# -- 解锁p1
  gaussdb=# CALL DBE_STATS.UNLOCK_PARTITION_STATS(ownname=>'dbe_stats_lock_unlock_partition', tabname=>'upart_table', partname=>'p1');
   unlock_partition_stats 
  ------------------------
  (1 row)
  gaussdb=# -- 验证p1已解锁 (全部 exist_lock = f)
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_PARTITION
  gaussdb-# WHERE parentid='upart_table'::REGCLASS
  gaussdb-# ORDER BY 1;
     relname   | exist_lock 
  -------------+------------
   p1          | f
   p2          | f
   p3          | f
   upart_table | f
  (4 rows)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE upart_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock_unlock_partition;
  DROP SCHEMA
  ```
  
- DBE_STATS.UNLOCK_COLUMN_STATS
  解锁一个列的统计信息。解锁后，该列的统计信息可以更新。该接口无返回值。
  DBE_STATS.UNLOCK_COLUMN_STATS原型为：
  ```
  DBE_STATS.UNLOCK_COLUMN_STATS(
      ownname     VARCHAR2,
      tabname     VARCHAR2,
      colname     VARCHAR2,
      partname    VARCHAR2 DEFAULT NULL
  );
  ```
  表8DBE_STATS.UNLOCK_COLUMN_STATS接口参数说明 
  | 参数      | 类型          | 是否允许为空 | 描述                                  |
  |:---|:---|:---|:---|
  | ownname  | varchar2   | 是        | 要解锁的列所属的schema的名称，该参数为空时，默认为当前schema。 |
  | tabname    | varchar2 | 否         | 要解锁的列所属的表的名称。                         |
  | colname | varchar2  | 否         | 要解锁的列的名称。                          |
  | partname  | varchar2 | 是       | 要解锁的列所属的分区的名称，默认为空。                  |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 当partname为空时，默认解锁该列表级统计信息，以及解锁其级联分区列级统计信息。
  
  - 可查看[PG_STATISTIC](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1257.html)、[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的stastate状态获取锁定状态。
  
  - 解锁多列时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_lock_unlock_column CASCADE;
  NOTICE:  schema "dbe_stats_lock_unlock_column" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_lock_unlock_column;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_lock_unlock_column;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(generate_series(1,100), 1);
  INSERT 0 100
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 先锁定列a
  gaussdb=# CALL DBE_STATS.LOCK_COLUMN_STATS(ownname=>'dbe_stats_lock_unlock_column', tabname=>'t1', colname=>'a');
   lock_column_stats 
  -------------------
  (1 row)
  gaussdb=# -- 验证列a已锁定 (stastate='l')
  gaussdb=# SELECT staattnum, stastate
  gaussdb-# FROM PG_STATISTIC
  gaussdb-# WHERE starelid='t1'::REGCLASS
  gaussdb-# ORDER BY 1, 2;
   staattnum | stastate 
  -----------+----------
           1 | l
           2 | u
  (2 rows)
  gaussdb=# -- 解锁列a
  gaussdb=# CALL DBE_STATS.UNLOCK_COLUMN_STATS(ownname=>'dbe_stats_lock_unlock_column', tabname=>'t1', colname=>'a');
   unlock_column_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证列a已解锁 (stastate='u')
  gaussdb=# SELECT staattnum, stastate
  gaussdb-# FROM PG_STATISTIC
  gaussdb-# WHERE starelid='t1'::REGCLASS
  gaussdb-# ORDER BY 1, 2;
   staattnum | stastate 
  -----------+----------
           1 | u
           2 | u
  (2 rows)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock_unlock_column;
  DROP SCHEMA
  ```
  
- DBE_STATS.UNLOCK_SCHEMA_STATS
  解锁一个指定schema下所有表的统计信息。该接口无返回值。
  DBE_STATS.UNLOCK_SCHEMA_STATS原型为：
  ```
  DBE_STATS.UNLOCK_SCHEMA_STATS(
      ownname    VARCHAR2
  );
  ```
  表9DBE_STATS.UNLOCK_SCHEMA_STATS接口参数说明 
  | 参数        | 类型       | 是否允许为空 | 描述                            |
  |:---|:---|:---|:---|
  | ownname | varchar2 | 是    | 指定的schema名，该参数为空时，默认为当前schema。 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_lock_unlock_schema CASCADE;
  NOTICE:  schema "dbe_stats_lock_unlock_schema" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表
  gaussdb=# CREATE SCHEMA dbe_stats_lock_unlock_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_lock_unlock_schema;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# CREATE TABLE t2(a int, b int);
  CREATE TABLE
  gaussdb=# -- 先锁定schema
  gaussdb=# CALL DBE_STATS.LOCK_SCHEMA_STATS(ownname=>'dbe_stats_lock_unlock_schema');
   lock_schema_stats 
  -------------------
  (1 row)
  gaussdb=# -- 验证已锁定 (exist_lock = t)
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_CLASS
  gaussdb-# WHERE relname IN ('t1','t2')
  gaussdb-#   AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock_unlock_schema')
  gaussdb-# ORDER BY 1;
   relname | exist_lock 
  ---------+------------
   t1      | t
   t2      | t
  (2 rows)
  gaussdb=# -- 解锁schema
  gaussdb=# CALL DBE_STATS.UNLOCK_SCHEMA_STATS(ownname=>'dbe_stats_lock_unlock_schema');
   unlock_schema_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证已解锁 (exist_lock = f)
  gaussdb=# SELECT relname, instr(reloptions::text,'stat_state=locked',1,1) <> 0 AS exist_lock
  gaussdb-# FROM PG_CLASS
  gaussdb-# WHERE relname IN ('t1','t2')
  gaussdb-#   AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_lock_unlock_schema')
  gaussdb-# ORDER BY 1;
   relname | exist_lock 
  ---------+------------
   t1      | f
   t2      | f
  (2 rows)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_lock_unlock_schema;
  DROP SCHEMA
  ```
  
- DBE_STATS.RESTORE_TABLE_STATS
  将表的统计信息回退到指定的时间节点，选择该时间节点前最后一次收集的统计信息载入系统表，同时级联其下级未被锁定的分区、索引、列级统计信息。该接口无返回值。
  DBE_STATS.RESTORE_TABLE_STATS原型为：
  ```
  DBE_STATS.RESTORE_TABLE_STATS(
      ownname                   VARCHAR2, 
      tabname                   VARCHAR2, 
      as_of_timestamp           TIMESTAMPTZ,
      restore_cluster_index     BOOLEAN DEFAULT NULL,
      force                     BOOLEAN DEFAULT FALSE,
      no_invalidate             BOOLEAN DEFAULT NULL
  );
  ```
  表10DBE_STATS.RESTORE_TABLE_STATS接口参数介绍 
  | 参数                    | 类型                        | 是否允许为空 | 描述                                 |
  |:---|:---|:---|:---|
  | ownname                | VARCHAR2                  | 是       | 要回退的表所属的schema名，该参数为空时，默认为当前schema。 |
  | tabname                | VARCHAR2                   | 否     | 要回退的表的名称。                             |
  | as_of_timestamp         | timestamp with time zone | 否      | 要回退的目标时间节点。                         |
  | restore_cluster_index | BOOLEAN                    | 是        | 暂不支持。                                |
  | force                   | BOOLEAN                   | 是        | 是否在统计信息被锁定时强行回退的标志位，默认为false。       |
  | no_invalidate           | BOOLEAN                   | 是       | 暂不支持。                               |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 调用该接口时，同时回退其下级分区、索引、列的统计信息，如果其下级的分区或列被锁定，则直接跳过。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集两次统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_restore;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_restore;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  -- 查看历史表。
  gaussdb=# SELECT relname,reltuples FROM GS_TABLESTATS_HISTORY WHERE relid='t1'::regclass ORDER BY 1,2;
   relname | reltuples 
  ---------+-----------
   t1      |         3
   t1      |         6
  (2 rows)
  -- 查看当前系统表中的统计信息。
  gaussdb=# SELECT relname,reltuples FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore');
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  -- 回退到最早的统计信息，查看系统表。
  gaussdb=# CALL DBE_STATS.RESTORE_TABLE_STATS(
  gaussdb(#     ownname=>'dbe_stats_restore',
  gaussdb(#     tabname=>'t1',
  gaussdb FROM GS_TABLESTATS_HISTORY
  gaussdb
  gaussdb);
   restore_table_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT relname,reltuples FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore');
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  -- 删除表、删除命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_restore;
  DROP SCHEMA
  ```
  
- DBE_STATS.RESTORE_PARTITION_STATS
  将分区的统计信息回退到指定的时间节点，选择该时间节点前最后一次收集的统计信息载入系统表，同时级联其下级未被锁定的分区、索引、列级统计信息。该接口无返回值。
  DBE_STATS.RESTORE_PARTITION_STATS原型为：
  ```
  DBE_STATS.RESTORE_PARTITION_STATS(
      ownname                   VARCHAR2, 
      tabname                   VARCHAR2, 
      partname                  VARCHAR2, 
      as_of_timestamp           TIMESTAMPTZ,
      force                     BOOLEAN DEFAULT FALSE,
      no_invalidate             BOOLEAN DEFAULT NULL
  );
  ```
  表11DBE_STATS.RESTORE_PARTITION_STATS接口参数说明 
  | 参数            | 类型                       | 是否允许为空 | 描述                  |
  |:---|:---|:---|:---|
  | ownname          | VARCHAR2                  | 是      | 要回退的分区所属的schema名。  |
  | tabname        | VARCHAR2                   | 否       | 要回退的分区所属的表名。         |
  | partname         | VARCHAR2                  | 否      | 要回退的分区名。           |
  | as_of_timestamp | timestamp with time zone | 否      | 要回退的目标时间节点。         |
  | force           | BOOLEAN                    | 是       | 是否在统计信息被锁定时强行回退的标志位。 |
  | no_invalidate  | BOOLEAN                   | 是      | 暂不支持。               |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 调用该接口时，同时回退其下级分区、索引、列的统计信息。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_restore_partition CASCADE;
  NOTICE:  schema "dbe_stats_restore_partition" does not exist, skipping
  DROP SCHEMA
  gaussdb=# CREATE SCHEMA dbe_stats_restore_partition;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_restore_partition;
  SET
  gaussdb-# CREATE TABLE t1(a int, b int) PARTITION BY RANGE(a)
  gaussdb-# (
  gaussdb,
  gaussdb
  gaussdb;
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# ANALYZE t1 PARTITION (p1);
  ANALYZE
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1 PARTITION (p1);
  ANALYZE
  gaussdb=# SELECT relname, relkind, reltuples FROM GS_TABLESTATS_HISTORY
  gaussdb-# WHERE relname='p1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore_partition')
  gaussdb-# ORDER BY reltuples;
   relname | relkind | reltuples 
  ---------+---------+-----------
   p1      | p       |         3
   p1      | p       |         6
  (2 rows)
  gaussdb=# SELECT relname, reltuples FROM PG_PARTITION
  gaussdb-# WHERE relname='p1' AND parentid = (SELECT oid FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore_partition'));
   relname | reltuples 
  ---------+-----------
   p1      |         6
  (1 row)
  gaussdb=# CALL DBE_STATS.RESTORE_PARTITION_STATS(
  gaussdb(#     ownname=>'dbe_stats_restore_partition',
  gaussdb(#     tabname=>'t1',
  gaussdb(#     partname=>'p1',
  gaussdb FROM GS_TABLESTATS_HISTORY WHERE relname='p1' AND relnamespace = 
  gaussdb)
  gaussdb;
   restore_partition_stats 
  -------------------------
  (1 row)
  gaussdb=# SELECT relname, reltuples FROM PG_PARTITION
  gaussdb-# WHERE relname='p1' AND parentid = (SELECT oid FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore_partition'));
   relname | reltuples 
  ---------+-----------
   p1      |         3
  (1 row)
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_restore_partition;
  DROP SCHEMA
  ```
  
- DBE_STATS.RESTORE_COLUMN_STATS
  将列的统计信息回退到指定的时间节点，选择该时间节点前最后一次收集的统计信息载入系统表。该接口无返回值。
  DBE_STATS.RESTORE_COLUMN_STATS原型为：
  ```
  DBE_STATS.RESTORE_COLUMN_STATS(
      ownname                   VARCHAR2, 
      tabname                   VARCHAR2, 
      colname                   VARCHAR2,
      partname                  VARCHAR2 DEFAULT NULL,
      as_of_timestamp           TIMESTAMPTZ,
      force                     BOOLEAN DEFAULT FALSE,
      no_invalidate             BOOLEAN DEFAULT NULL
  );
  ```
  表12DBE_STATS.RESTORE_COLUMN_STATS接口参数说明 
  | 参数             | 类型                        | 是否允许为空 | 描述                     |
  |:---|:---|:---|:---|
  | ownname          | VARCHAR2                | 是    | 要回退的列所属的schema名。      |
  | tabname           | VARCHAR2                  | 否      | 要回退的列所属的表名。          |
  | colname          | VARCHAR2                  | 否       | 要回退的列名。                |
  | partname         | VARCHAR2                  | 是      | 要回退的列所属的分区名。           |
  | as_of_timestamp | timestamp with time zone | 否      | 要回退的目标时间节点。          |
  | force              | BOOLEAN                 | 是     | 是否在统计信息被锁定时强行回退的标志位。 |
  | no_invalidate     | BOOLEAN                   | 是      | 暂不支持。                |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 当partname为空时，默认回退该列表及统计信息。
  
  - 回退多列时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_restore_column CASCADE;
  NOTICE:  schema "dbe_stats_restore_column" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集两次统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_restore_column;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_restore_column;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 查看历史表里的统计信息
  gaussdb=# SELECT staattnum, stadistinct, stakind1, stanumbers1, stavalues1
  gaussdb-# FROM GS_STATISTIC_HISTORY
  gaussdb-# WHERE starelid='t1'::REGCLASS
  gaussdb-# ORDER BY statimestamp;
   staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  -----------+-------------+----------+-------------+------------
           1 |    -.333333 |        1 | {1}         | {1}
           2 |    -.333333 |        1 | {1}         | {1}
           1 |    -.333333 |        1 | {.5,.5}     | {1,2}
           2 |    -.333333 |        1 | {.5,.5}     | {1,2}
  (4 rows)
  gaussdb=# -- 查询当前系统表中的统计信息
  gaussdb=# SELECT staattnum, stadistinct, stakind1, stanumbers1, stavalues1
  gaussdb-# FROM PG_STATISTIC
  gaussdb-# WHERE starelid='t1'::REGCLASS
  gaussdb-# ORDER BY 1;
   staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  -----------+-------------+----------+-------------+------------
           1 |    -.333333 |        1 | {.5,.5}     | {1,2}
           2 |    -.333333 |        1 | {.5,.5}     | {1,2}
  (2 rows)
  gaussdb=# -- 回退列a到时间较早的时间节点
  gaussdb=# CALL DBE_STATS.RESTORE_COLUMN_STATS(
  gaussdb(#     ownname=>'dbe_stats_restore_column',
  gaussdb(#     tabname=>'t1',
  gaussdb(#     colname=>'a',
  gaussdb FROM GS_TABLESTATS_HISTORY WHERE relname='t1'
  gaussdb)
  gaussdb;
   restore_column_stats 
  ----------------------
  (1 row)
  gaussdb=# -- 验证回退后列a的统计信息
  gaussdb=# SELECT staattnum, stadistinct, stakind1, stanumbers1, stavalues1
  gaussdb-# FROM PG_STATISTIC
  gaussdb-# WHERE starelid='t1'::REGCLASS
  gaussdb-# ORDER BY 1;
   staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  -----------+-------------+----------+-------------+------------
           1 |    -.333333 |        1 | {1}         | {1}
           2 |    -.333333 |        1 | {.5,.5}     | {1,2}
  (2 rows)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_restore_column;
  DROP SCHEMA
  ```
  
- DBE_STATS.RESTORE_SCHEMA_STATS
  将指定schema下所有表的统计信息回退到指定时间节点。该接口无返回值。
  DBE_STATS.RESTORE_SCHEMA_STATS原型为：
  ```
  DBE_STATS.RESTORE_SCHEMA_STATS(
      ownname                   VARCHAR2, 
      as_of_timestamp           TIMESTAMPTZ,
      force                     BOOLEAN DEFAULT FALSE,
      no_invalidate             BOOLEAN DEFAULT NULL
  );
  ```
  表13DBE_STATS.RESTORE_SCHEMA_STATS接口参数说明 
  | 参数                | 类型                      | 是否允许为空 | 描述                    |
  |:---|:---|:---|:---|
  | ownname          | VARCHAR2               | 是       | 指定的schema名。            |
  | as_of_timestamp | timestamp with time zone | 否     | 要回退的目标时间节点。          |
  | force           | BOOLEAN               | 是        | 是否在统计信息被锁定时强行回退的标志位。 |
  | no_invalidate  | BOOLEAN                | 是      | 暂不支持。                  |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
  示例：
  ```
  -- 回退schema的统计信息同回退表的统计信息用法一致。
  -- 建表，插数据，收集两次统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_restore;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_restore;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  -- 查看系统表。
  gaussdb=# SELECT relname,reltuples FROM GS_TABLESTATS_HISTORY WHERE relid='t1'::regclass ORDER BY 1,2;
   relname | reltuples 
  ---------+-----------
   t1      |         3
   t1      |         6
  (2 rows
  gaussdb=# SELECT relname,reltuples FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore');
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  -- 回退。
  gaussdb=# CALL DBE_STATS.RESTORE_SCHEMA_STATS(
  gaussdb(#     ownname=>'dbe_stats_restore',
  gaussdb FROM GS_TABLESTATS_HISTORY
  gaussdb
  gaussdb);
   restore_schema_stats 
  ----------------------
  (1 row)
  -- 再次查看系统表。
  gaussdb=# SELECT relname,reltuples FROM PG_CLASS WHERE relname='t1' AND relnamespace = (SELECT oid FROM PG_NAMESPACE WHERE nspname='dbe_stats_restore');
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_restore;
  DROP SCHEMA
  ```
  
- DBE_STATS.PURGE_STATS
  清除指定时间节点之前的所有历史统计信息。该接口无返回值。
  DBE_STATS.PURGE_STATS原型为：
  ```
  DBE_STATS.PURGE_STATS(
      before_timestamp       TIMESTAMPTZ
  );
  ```
  表14DBE_STATS.PURGE_STATS接口参数说明 
  | 参数              | 类型                      | 是否允许为空 | 描述          |
  |:---|:---|:---|:---|
  | before_timestamp | timestamp with time zone | 否        | 指定要清除的时间节点。 |
     
  示例：
  ```
  -- 建表，收集两次统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_purge;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_purge;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(1,1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES(2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  -- 查看历史表。
  gaussdb=# SELECT relname,reltuples FROM GS_TABLESTATS_HISTORY WHERE relname='t1' ORDER BY 1,2;
   relname | reltuples 
  ---------+-----------
   t1      |         3
   t1      |         6
  (2 rows)
  -- 清除时间较早的历史统计信息，查看历史表。
  gaussdb=# CALL DBE_STATS.PURGE_STATS(before_timestamp=>((SELECT MIN(reltimestamp) FROM GS_TABLESTATS_HISTORY WHERE relname='t1') + INTERVAL '1 second'));
   purge_stats 
  -------------
  (1 row)
  gaussdb=# SELECT relname,reltuples FROM GS_TABLESTATS_HISTORY WHERE relname='t1';
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_purge;
  DROP SCHEMA
  ```
  
- DBE_STATS.GET_STATS_HISTORY_RETENTION
  获得当前历史统计信息的保留时间，返回用DBE_STATS.ALTER_STATS_HISTORY_RETENTION接口设置的保留时间。该接口没有入参。
  DBE_STATS.GET_STATS_HISTORY_RETENTION原型为：
  ```
  DBE_STATS.GET_STATS_HISTORY_RETENTION()
  returns NUMBER;
  ```
  示例：
  ```
  gaussdb=# CALL DBE_STATS.GET_STATS_HISTORY_RETENTION();
   get_stats_history_retention 
  -----------------------------
                            31
  (1 row)
  ```
  
- DBE_STATS.GET_STATS_HISTORY_AVAILABILITY
  获得当前历史统计信息的最早可用时间，返回当前数据库下所有历史统计信息的最早时间。该接口没有入参。
  DBE_STATS.GET_STATS_HISTORY_AVAILABILITY原型为：
  ```
  DBE_STATS.GET_STATS_HISTORY_AVAILABILITY()
  returns TIMESTAMPTZ;
  ```
  示例：
  ```
  gaussdb=# ANALYZE;
  ANALYZE
  gaussdb=# CALL DBE_STATS.GET_STATS_HISTORY_AVAILABILITY();
   get_stats_history_availability 
  --------------------------------
   2023-08-27 02:07:04.065217+08
  (1 row)
  ```
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 以上所有接口函数原型都具备同等数据类型和字段的C_FUNCTION函数原型，命名为DBE_STATS.XXXX_C_FUNCTION。
  
  - DBE_STATS高级包接口仅对普通表有效。
    

- DBE_STATS.CREATE_STAT_TABLE
  创建用于保存用户统计信息的统计表。该接口无返回值。
  DBE_STATS.CREATE_STAT_TABLE原型为：
  ```
  DBE_STATS.CREATE_STAT_TABLE (
      ownname          VARCHAR2,
      stattab          VARCHAR2,
      tblspace         VARCHAR2 DEFAULT NULL,
      global_temporary BOOLEAN DEFAULT NULL
  );
  ```
  表15DBE_STATS.CREATE_STAT_TABLE接口参数说明 
  | 参数               | 类型        | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname          | VARCHAR2   | 否     | 指定创建的统计表所在的schema。如果设置为null，默认在当前所在的schema创建。 |
  | stattab        | VARCHAR2 | 否     | 统计表的名称。                                         |
  | tblspace        | VARCHAR2  | 是      | 指定创建的统计表所在的表空间。如果不指定，则使用默认表空间进行创建。               |
  | global_temporary | BOOLEAN  | 是      | 暂不支持该参数。                                        |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 为了区分普通表和统计表，在创建统计表后，其reloptions中的字段statstable将不为空串。且考虑到统计表结构后续存在升级的可能，为了实现前向兼容，statstable将被赋予当前统计信息表的版本信息。
  
  - 该表创建时会自动生成一个索引gs_stattab_oid_statid_type_nameinfo_index用于索引扫描，其中oid为该统计信息表的oid。如若被删除，则导入导出export、import接口不可用。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 在dbe_stats_create_drop_schema下创建一个stattab统计表，并手动插入一条数据，可从新建的用户统计信息表中查询到此条数据。
  gaussdb=# CREATE SCHEMA dbe_stats_create_drop_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_create_drop_schema;
  SET
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE(ownname => 'dbe_stats_create_drop_schema', stattab => 'stat_tab');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# INSERT INTO stat_tab(statid, type, relname) VALUES('123', 't', 't1');
  INSERT 0 1
  gaussdb=# SELECT statid, type, relname FROM stat_tab;
   statid | type | relname 
  --------+------+---------
   123    | t    | t1
  (1 row)
  ```
  

- DBE_STATS.DROP_STAT_TABLE
  删除用户统计信息表。该接口无返回值。
  DBE_STATS.DROP_STAT_TABLE原型为：
  ```
  DBE_STATS.DROP_STAT_TABLE (
      ownname VARCHAR2, 
      stattab VARCHAR2
  );
  ```
  表16DBE_STATS.DROP_STAT_TABLE接口参数说明 
  | 参数        | 类型          | 是否允许为空 | 描述                                    |
  |:---|:---|:---|:---|
  | ownname | VARCHAR2 | 否      | 统计表所在的schema。如果设置为null，则默认使用当前schema。 |
  | stattab   | VARCHAR2    | 否        | 统计表的名称。                              |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 对于statstable属性为空的普通表，无法使用此函数删除。
  
  - 如果在用户统计信息表上创建了索引或者创建了其他依赖于该表的对象，那么在调用此函数时，会级联删除所有依赖于该表的对象。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 删除用户统计信息表。将上述所建的用户统计信息表删除，删除新建的schema。
  gaussdb=# CALL DBE_STATS.DROP_STAT_TABLE(ownname => 'dbe_stats_create_drop_schema', stattab => 'stat_tab');
   drop_stat_table 
  -----------------
  (1 row)
  gaussdb=# DROP SCHEMA dbe_stats_create_drop_schema CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.EXPORT_INDEX_STATS
  在系统表中查找指定索引的统计信息，并将结果存储在用户统计信息表中。该接口无返回值。
  DBE_STATS.EXPORT_INDEX_STATS原型为：
  ```
  DBE_STATS.EXPORT_INDEX_STATS (
  ownname  VARCHAR2,
  indname  VARCHAR2, 
  partname VARCHAR2 DEFAULT NULL,
  stattab  VARCHAR2, 
  statid   VARCHAR2 DEFAULT NULL,
  statown  VARCHAR2 DEFAULT NULL
  );
  ```
  表17DBE_STATS.EXPORT_INDEX_STATS接口参数说明 
  | 参数        | 类型       | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname   | VARCHAR2 | 否        | 指定索引所在schema的名称，如果设置为null，会默认使用当前的schema。       |
  | indname  | VARCHAR2    | 否       | 指定需要导出统计信息的索引名。                                   |
  | partname | VARCHAR2  | 是     | 分区索引的名称。如果索引已分区但是partname为null，则导出全局和分区索引统计信息。    |
  | stattab  | VARCHAR2  | 否        | 指定存储统计信息用户表的表名。                                  |
  | statid    | VARCHAR2  | 是      | 指向stattab中统计信息的标识符（可选）。                           |
  | statown   | VARCHAR2  | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导出索引的reltuples（numrows）、relpages（numlblks）和relallvisible（relallvisible）三类统计信息。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_export;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export;
  SET
  gaussdb=# CREATE TABLE t2(a int, b int, c int) PARTITION BY RANGE(a) SUBPARTITION BY RANGE(b)
   (
      PARTITION p1 VALUES LESS THAN(200)
      (SUBPARTITION s1 VALUES LESS THAN (500),
       SUBPARTITION s2 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p2 VALUES LESS THAN(500)
      (SUBPARTITION s3 VALUES LESS THAN (500),
       SUBPARTITION s4 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p3 VALUES LESS THAN(MAXVALUE)
      ( SUBPARTITION s5 VALUES LESS THAN (500),
        SUBPARTITION s6 VALUES LESS THAN (MAXVALUE)
      )
   );
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t2_local_a ON t2(a) LOCAL
   (
       PARTITION p1_idx_a
       (
           SUBPARTITION s1_idx_a,
           SUBPARTITION s2_idx_a
       ),
       PARTITION p2_idx_a
       (
           SUBPARTITION s3_idx_a,
           SUBPARTITION s4_idx_a
       ),
       PARTITION p3_idx_a
       (
           SUBPARTITION s5_idx_a,
           SUBPARTITION s6_idx_a
       ));
  CREATE INDEX
  gaussdb=# INSERT INTO t2 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 400, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 600, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t2 WITH ALL;
  ANALYZE
  gaussdb=# ANALYZE t2((a,b)) WITH ALL;
  ANALYZE
  -- 建立用户统计信息表，作为统计信息导出的目标表。
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_export', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  -- 导出索引统计信息，连同分区索引的统计信息一并导出。
  -- 查看当前的统计信息。
  gaussdb=# SELECT relpages,reltuples FROM PG_CLASS WHERE relname='idx_t2_local_a';
   relpages | reltuples 
  ----------+-----------
          6 |         6
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples 
  ----------+----------+-----------
   s1_idx_a |        1 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 导出统计信息，查看用户统计信息表中的数据。
  gaussdb=# CALL DBE_STATS.EXPORT_INDEX_STATS(ownname => 'dbe_stats_export', indname => 'idx_t2_local_a', partname=> null, stattab => 'export_table', statid => 'idx_s1');
   export_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relname,partname,numrows,numblocks FROM export_table ORDER BY relname, partname desc;
      relname     | partname | numrows | numblocks 
  ----------------+----------+---------+-----------
   idx_t2_local_a |          |       6 |         6
   idx_t2_local_a | s6_idx_a |       0 |         1
   idx_t2_local_a | s5_idx_a |       0 |         1
   idx_t2_local_a | s4_idx_a |       0 |         1
   idx_t2_local_a | s3_idx_a |       0 |         1
   idx_t2_local_a | s2_idx_a |       0 |         1
   idx_t2_local_a | s1_idx_a |       0 |         1
  (7 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP INDEX idx_t2_local_a;
  DROP INDEX
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_export;
  DROP SCHEMA
  ```
  

- DBE_STATS.EXPORT_TABLE_STATS
  检索指定表的统计信息，并存储在用户统计信息表中。该接口无返回值。
  DBE_STATS.EXPORT_TABLE_STATS原型为：
  ```
  DBE_STATS.EXPORT_TABLE_STATS (
     ownname           VARCHAR2, 
     tabname           VARCHAR2, 
     partname          VARCHAR2 DEFAULT NULL,
     stattab           VARCHAR2, 
     statid            VARCHAR2 DEFAULT NULL,
     cascade           BOOLEAN  DEFAULT TRUE,
     statown           VARCHAR2 DEFAULT NULL,
     stat_category     VARCHAR2 DEFAULT NULL
  );
  ```
  表18DBE_STATS.EXPORT_TABLE_STATS接口参数说明 
  | 参数            | 类型         | 是否允许为空 | 描述                                               |
  |:---|:---|:---|:---|
  | ownname      | VARCHAR2    | 否      | 指定schema的名称，如果设置为null，会默认使用当前的schema。             |
  | tabname         | VARCHAR2 | 否      | 指定需要导出统计信息的表名。                                   |
  | partname     | VARCHAR2   | 是        | 表分区的名称。如果表已分区但是partname为null，则导出全局和分区表统计信息。     |
  | stattab       | VARCHAR2   | 否      | 指定存储统计信息用户表的表名。                                  |
  | statid         | VARCHAR2   | 是       | 指向stattab中统计信息的标识符（可选）。                         |
  | cascade       | BOOLEAN    | 是       | 是否一并导出列、索引、多列和索引表达式的统计信息。默认为TRUE。                 |
  | statown        | VARCHAR2    | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
  | stat_category | VARCHAR2  | 是        | 暂不支持。                                           |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导出表的reltuples（numrows）、relpages（numblks）和relallvisible（relallvisible）三类统计信息。级联导出列级、索引级的统计信息参考[EXPORT_INDEX_STATS]和[EXPORT_COLUMN_STATS]接口的统计信息。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_export_table CASCADE;
  NOTICE:  schema "dbe_stats_export_table" does not exist, skipping
  DROP SCHEMA
  gaussdb=# CREATE SCHEMA dbe_stats_export_table;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export_table;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int, c int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_export_table', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# -- 导出表统计信息 (级联导出列、索引统计信息)
  gaussdb=# CALL DBE_STATS.EXPORT_TABLE_STATS(
  gaussdb(#     ownname => 'dbe_stats_export_table',
  gaussdb(#     tabname => 't1',
  gaussdb(#     partname => null,
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 't1_t',
  gaussdb(#     cascade => true
  gaussdb;
   export_table_stats 
  --------------------
  (1 row)
  gaussdb=# -- 验证: 用户统计信息表中应有数据
  gaussdb=# SELECT count(*) AS row_count FROM export_table WHERE relname='t1';
   row_count 
  -----------
           4
  (1 row)
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_export_table;
  DROP SCHEMA
  ```
  

- DBE_STATS.EXPORT_COLUMN_STATS
  检索指定列（多列/表达式）的统计信息并存储在用户统计信息表中。该接口无返回值。
  DBE_STATS.EXPORT_COLUMN_STATS原型为：
  ```
  DBE_STATS.EXPORT_COLUMN_STATS (
     ownname  VARCHAR2, 
     tabname  VARCHAR2, 
     colname  VARCHAR2, 
     partname VARCHAR2 DEFAULT NULL,
     stattab  VARCHAR2, 
     statid   VARCHAR2 DEFAULT NULL,
     statown  VARCHAR2 DEFAULT NULL
  );
  ```
  表19DBE_STATS.EXPORT_COLUMN_STATS接口参数说明 
  | 参数       | 类型          | 是否允许为空 | 描述                                                      |
  |:---|:---|:---|:---|
  | ownname   | VARCHAR2   | 否      | 指定schema的名称，如果设置为null，会默认使用当前的schema。                    |
  | tabname    | VARCHAR2   | 否    | 指定需要导出统计信息的列所属的表名（表达式对应索引名）。                            |
  | colname  | VARCHAR2    | 否      | 列名或者多列名（tabname为索引时，colname为表达式名）。                      |
  | partname | VARCHAR2   | 是     | 分区的名称。如果表/索引已分区但是partname为null，则导出全局和分区列/多列/索引表达式统计信息。 |
  | stattab   | VARCHAR2   | 否     | 指定存储统计信息用户表的表名。                                          |
  | statid    | VARCHAR2    | 是        | 指向stattab中统计信息的标识符（可选）。                                 |
  | statown     | VARCHAR2 | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。       |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导出列级的统计信息可查询[PG_STATISTIC](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1257.html)或者[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)。
  
  - 导出多列统计信息时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_export;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA=dbe_stats_export;
  SET
  gaussdb=# CREATE TABLE IF NOT EXISTS t1 (a int, b int, c int);
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t1_expr on t1((a*a), (a+a), (a*b)); 
  CREATE INDEX
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# ANALYZE t1((a,b));
  ANALYZE
  -- 建立用户统计信息表。
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_export', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  -- 查看列级统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 | stanumbers1 |  stavalues1   
  -----------+-------------+----------+-------------+---------------
           1 |          -1 |        2 |             | {100,150,250}
           2 |          -1 |        2 |             | {150,300,550}
           3 |    -.333333 |        1 | {1}         | {1}
  (3 rows)
  -- 导出列级统计信息，查看用户统计信息表。
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_export', tabname => 't1', colname=> 'a', partname => null, stattab => 'export_table', statid => 't1_c');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT relname,columnname,stadistinct,stakind1,stanumbers1,stavalues1 FROM export_table;
   relname | columnname | stadistinct | stakind1 | stanumbers1 |  stavalues1   
  ---------+------------+-------------+----------+-------------+---------------
   t1      | a          |          -1 |        2 |             | {100,150,250}
  (1 row)
  -- 查看表达式统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 | stanumbers1 |     stavalues1      
  -----------+-------------+----------+-------------+---------------------
           1 |          -1 |        2 |             | {10000,22500,62500}
           2 |          -1 |        2 |             | {200,300,500}
           3 |          -1 |        2 |             | {30000,37500,82500}
  (3 rows)
  -- 导出表达式统计信息，查看用户统计信息表。
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_export', tabname => 'idx_t1_expr', colname => 'expr', stattab => 'export_table', statid => 't1_expr');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT relname,columnname,stadistinct,stakind1,stanumbers1,stavalues1 FROM export_table where statid='t1_expr';
     relname   | columnname | stadistinct | stakind1 | stanumbers1 |     stavalues1    
  -------------+------------+-------------+----------+-------------+---------------------
   idx_t1_expr | expr       |          -1 |        2 |             | {10000,22500,62500}
  (1 row)
  -- 导出多列统计信息。
  -- 查看多列统计信息。
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+---------------------+-------------+----------+-------------+------------
   1 2    | extname_-1308656218 |          -1 |        8 |             | 
  (1 row)
  -- 导出，查看用户统计信息表。
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_export', tabname => 't1', colname=> 'extname_-1308656218', partname => null, stattab => 'export_table', statid => 't1_c');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT relname,columnname,stadistinct,stakind1,stanumbers1,stavalues1 FROM export_table WHERE relname = 't1' ORDER BY 1,2;
   relname |     columnname      | stadistinct | stakind1 | stanumbers1 |  stavalues1   
  ---------+---------------------+-------------+----------+-------------+---------------
   t1      | a                   |          -1 |        2 |             | {100,150,250}
   t1      | extname_-1308656218 |          -1 |        8 |             | 
  (2 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_export;
  DROP SCHEMA
  ```
  

- DBE_STATS.EXPORT_SCHEMA_STATS
  用于检索指定schema的统计信息，并存储在用户统计信息表中。该接口无返回值。
  DBE_STATS.EXPORT_SCHEMA_STATS原型为：
  ```
  DBE_STATS.EXPORT_SCHEMA_STATS (
     ownname         VARCHAR2, 
     stattab         VARCHAR2, 
     statid          VARCHAR2 DEFAULT NULL,
     statown         VARCHAR2 DEFAULT NULL,
     stat_category   VARCHAR2 DEFAULT NULL
  );
  ```
  表20DBE_STATS.EXPORT_SCHEMA_STATS接口参数说明 
  | 参数            | 类型       | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname       | VARCHAR2 | 否       | 指定schema的名称，如果设置为null，会默认使用当前的schema。              |
  | stattab       | VARCHAR2 | 否      | 指定存储统计信息用户表的表名。                                    |
  | statid       | VARCHAR2  | 是       | 指向stattab中统计信息的标识符（可选）。                          |
  | statown        | VARCHAR2 | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
  | stat_category | VARCHAR2   | 是      | 暂不支持。                                             |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导出当前用户在指定schema下所有具有权限的表的统计信息，对于无权限的表直接跳过，不报错。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_export_schema CASCADE;
  NOTICE:  schema "dbe_stats_export_schema" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_export_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export_schema;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# CREATE TABLE t2(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t2 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t2;
  ANALYZE
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_export_schema', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# -- 导出schema统计信息
  gaussdb=# CALL DBE_STATS.EXPORT_SCHEMA_STATS(
  gaussdb(#     ownname => 'dbe_stats_export_schema',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1'
  gaussdb;
   export_schema_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证: 用户统计信息表中应有数据
  gaussdb=# SELECT count(*) AS row_count FROM export_table;
   row_count 
  -----------
           8
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_export_schema;
  DROP SCHEMA
  ```
  

- DBE_STATS.EXPORT_DATABASE_STATS
  用于检索指定database的统计信息，并存储在用户统计信息表中。该接口无返回值。
  DBE_STATS.EXPORT_DATABASE_STATS原型：
  ```
  DBE_STATS.EXPORT_DATABASE_STATS (
     stattab         VARCHAR2, 
     statid          VARCHAR2 DEFAULT NULL,
     statown         VARCHAR2 DEFAULT NULL,
     stat_category   VARCHAR2 DEFAULT NULL
  );
  ```
  表21DBE_STATS.EXPORT_DATABASE_STATS接口参数说明 
  | 参数           | 类型       | 是否允许为空 | 描述                                         |
  |:---|:---|:---|:---|
  | stattab      | VARCHAR2   | 否        | 指定存储统计信息用户表的表名。                               |
  | statid       | VARCHAR2 | 是       | 指向stattab中统计信息的标识符（可选）。                     |
  | statown      | VARCHAR2  | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用当前Schema。 |
  | stat_category | VARCHAR2  | 是      | 暂不支持。                                        |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导出当前用户在当前database下所有具有analyze权限用户表的统计信息，对于无权限的表直接跳过，不报错。
  
  - 当statown参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_export_database CASCADE;
  NOTICE:  schema "dbe_stats_export_database" does not exist, skipping
  DROP SCHEMA
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_export_database1 CASCADE;
  NOTICE:  schema "dbe_stats_export_database1" does not exist, skipping
  DROP SCHEMA
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_export_database2 CASCADE;
  NOTICE:  schema "dbe_stats_export_database2" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_export_database1;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export_database1;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# CREATE SCHEMA dbe_stats_export_database2;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export_database2;
  SET
  gaussdb=# CREATE TABLE t2(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t2 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (2,2);
  INSERT 0 1
  gaussdb=# ANALYZE t2;
  ANALYZE
  gaussdb=# CREATE SCHEMA dbe_stats_export_database;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_export_database;
  SET
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_export_database', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# -- 导出database统计信息
  gaussdb=# CALL DBE_STATS.EXPORT_DATABASE_STATS(
  gaussdb(#     statown => 'dbe_stats_export_database',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1'
  gaussdb;
   export_database_stats 
  -----------------------
  (1 row)
  gaussdb=# -- 验证: 用户统计信息表中应有数据
  gaussdb=# SELECT count(*) AS row_count FROM export_table;
   row_count 
  -----------
           8
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP TABLE dbe_stats_export_database1.t1;
  DROP TABLE
  gaussdb=# DROP TABLE dbe_stats_export_database2.t2;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_export_database;
  DROP SCHEMA
  gaussdb=# DROP SCHEMA dbe_stats_export_database1;
  DROP SCHEMA
  gaussdb=# DROP SCHEMA dbe_stats_export_database2;
  DROP SCHEMA
  ```
  
- DBE_STATS.IMPORT_INDEX_STATS
  从stattab标识的用户统计信息表中检索指定索引的统计信息，并将其写回系统表中。该接口无返回值。
  DBE_STATS.IMPORT_INDEX_STATS原型为：
  ```
  DBE_STATS.IMPORT_INDEX_STATS (
     ownname       VARCHAR2, 
     indname       VARCHAR2,
     partname      VARCHAR2 DEFAULT NULL,
     stattab       VARCHAR2, 
     statid        VARCHAR2 DEFAULT NULL,
     statown       VARCHAR2 DEFAULT NULL,
     no_invalidate BOOLEAN DEFAULT NULL,
     force         BOOLEAN DEFAULT FALSE
  );
  ```
  表22DBE_STATS.IMPORT_INDEX_STATS接口参数说明 
  | 参数            | 类型       | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname       | VARCHAR2  | 否       | 指定schema的名称，如果设置为null，会默认使用当前的schema。              |
  | indname      | VARCHAR2  | 否       | 指定需要导入统计信息的索引名。                                 |
  | partname        | VARCHAR2  | 是      | 索引分区的名称。如果索引已分区但是partname为null，则导入全局和分区索引统计信息。  |
  | stattab         | VARCHAR2 | 否      | 指定存储统计信息用户表的表名。                                 |
  | statid          | VARCHAR2  | 是       | 指向stattab中统计信息的标识符（可选）。                          |
  | statown       | VARCHAR2  | 是        | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
  | no_invalidate | BOOLEAN   | 是       | 暂不支持。                                             |
  | force          | BOOLEAN   | 是     | 是否强制导入，忽略锁的状态，默认false。                          |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导入索引的reltuples（numrows）、relpages（numlblks）和relallvisible（relallvisible）三类统计信息。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_import;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_import;
  SET
  gaussdb=# CREATE TABLE t2(a int, b int, c int) PARTITION BY RANGE(a) SUBPARTITION BY RANGE(b)
   (
      PARTITION p1 VALUES LESS THAN(200)
      (SUBPARTITION s1 VALUES LESS THAN (500),
       SUBPARTITION s2 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p2 VALUES LESS THAN(500)
      (SUBPARTITION s3 VALUES LESS THAN (500),
       SUBPARTITION s4 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p3 VALUES LESS THAN(MAXVALUE)
      ( SUBPARTITION s5 VALUES LESS THAN (500),
        SUBPARTITION s6 VALUES LESS THAN (MAXVALUE)
      )
   );
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t2_local_a ON t2(a) LOCAL
   (
       PARTITION p1_idx_a
       (
           SUBPARTITION s1_idx_a,
           SUBPARTITION s2_idx_a
       ),
       PARTITION p2_idx_a
       (
           SUBPARTITION s3_idx_a,
           SUBPARTITION s4_idx_a
       ),
       PARTITION p3_idx_a
       (
           SUBPARTITION s5_idx_a,
           SUBPARTITION s6_idx_a
       ));
  CREATE INDEX
  gaussdb=# INSERT INTO t2 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 400, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 600, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t2 WITH ALL;
  ANALYZE
  -- 创建用户统计信息表，先将数据导出。
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_import', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_INDEX_STATS(ownname => 'dbe_stats_import', indname => 'idx_t2_local_a', partname=> null, stattab => 'export_table', statid => 'idx_s1');
   export_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relname,partname,numrows,numblocks FROM export_table ORDER BY relname,partname desc;
      relname     | partname | numrows | numblocks 
  ----------------+----------+---------+-----------
   idx_t2_local_a |          |       6 |         6
   idx_t2_local_a | s6_idx_a |       0 |         1
   idx_t2_local_a | s5_idx_a |       0 |         1
   idx_t2_local_a | s4_idx_a |       0 |         1
   idx_t2_local_a | s3_idx_a |       0 |         1
   idx_t2_local_a | s2_idx_a |       0 |         1
   idx_t2_local_a | s1_idx_a |       0 |         1
  (7 rows)
  -- 再次插入数据，收集统计信息，查看统计信息。
  gaussdb=# INSERT INTO t2 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 400, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 600, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t2 WITH ALL;
  ANALYZE
  gaussdb=# SELECT relpages,reltuples FROM PG_CLASS WHERE relname='idx_t2_local_a';
   relpages | reltuples 
  ----------+-----------
          6 |        12
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples 
  ----------+----------+-----------
   s1_idx_a |        1 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 将用户统计表中的统计信息导入统计信息系统表。
  gaussdb=# CALL DBE_STATS.IMPORT_INDEX_STATS(ownname => 'dbe_stats_import', indname => 'idx_t2_local_a', stattab => 'export_table', statid => 'idx_s1');
   import_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relpages,reltuples FROM PG_CLASS WHERE relname='idx_t2_local_a';
   relpages | reltuples 
  ----------+-----------
          6 |         6
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples 
  ----------+----------+-----------
   s1_idx_a |        1 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_import;
  DROP SCHEMA
  ```
  

- DBE_STATS.IMPORT_TABLE_STATS
  从stattab标识的用户统计信息表中检索指定表的统计信息，并将其写回系统表中。该接口无返回值。
  DBE_STATS.IMPORT_TABLE_STATS原型为：
  ```
  DBE_STATS.IMPORT_TABLE_STATS (
     ownname       VARCHAR2, 
     tabname       VARCHAR2,
     partname      VARCHAR2 DEFAULT NULL,
     stattab       VARCHAR2, 
     statid        VARCHAR2 DEFAULT NULL,
     cascade       BOOLEAN  DEFAULT TRUE,
     statown       VARCHAR2 DEFAULT NULL,
     no_invalidate BOOLEAN  DEFAULT NULL,
     force         BOOLEAN  DEFAULT FALSE,
     stat_category VARCHAR2 DEFAULT NULL
  );
  ```
  表23DBE_STATS.IMPORT_TABLE_STATS接口参数说明 
  | 参数            | 类型       | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname       | varchar2 | 否      | 指定schema的名称，如果设置为null，会默认使用当前的schema。         |
  | tabname        | varchar2    | 否      | 指定需要导入统计信息的表名。                                  |
  | partname     | varchar2   | 是       | 表分区的名称。如果表已分区但是partname为null，则导入全局和分区表统计信息。     |
  | stattab       | varchar2 | 否        | 指定存储统计信息用户表的表名。                                 |
  | statid        | varchar2 | 是       | 指向stattab中统计信息的标识符（可选）。                           |
  | cascade        | boolean    | 是      | 是否一并导入列、索引、多列和索引表达式的统计信息。默认为true。              |
  | statown       | varchar2   | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
  | no_invalidate | boolean  | 是        | 暂不支持。                                            |
  | force         | boolean | 是       | 是否强制导入，忽略锁的状态，默认false。                         |
  | stat_category | varchar2  | 是         | 暂不支持。                                            |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导入表的reltuples（numrows）、relpages（numblks）和relallvisible（relallvisible）三类统计信息。级联导入列级、索引级的统计信息参考[IMPORT_INDEX_STATS]和[IMPORT_COLUMN_STATS]接口的统计信息。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_import_table CASCADE;
  NOTICE:  schema "dbe_stats_import_table" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_import_table;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_import_table;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (3,3);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 创建用户统计信息表，导出表统计信息
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_import_table', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_TABLE_STATS(
  gaussdb(#     ownname => 'dbe_stats_import_table',
  gaussdb(#     tabname => 't1',
  gaussdb(#     partname => null,
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 't1_t',
  gaussdb(#     cascade => true
  gaussdb;
   export_table_stats 
  --------------------
  (1 row)
  gaussdb=# -- 验证: 导出前 reltuples=3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 再次插入数据，收集统计信息
  gaussdb=# INSERT INTO t1 VALUES (4,4);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (5,5);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (6,6);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 验证: 统计信息已更新 reltuples=6
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  gaussdb=# -- 导入之前的统计信息
  gaussdb=# CALL DBE_STATS.IMPORT_TABLE_STATS(
  gaussdb(#     ownname => 'dbe_stats_import_table',
  gaussdb(#     tabname => 't1',
  gaussdb(#     partname => null,
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 't1_t',
  gaussdb(#     cascade => true,
  gaussdb(#     force => false
  gaussdb;
   import_table_stats 
  --------------------
  (1 row)
  gaussdb=# -- 验证: 导入后 reltuples恢复为3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_import_table;
  DROP SCHEMA
  ```
  

- DBE_STATS.IMPORT_COLUMN_STATS
  从stattab标识的用户统计信息表中检索指定列（多列/表达式）的统计信息，并将其写回系统表中。该接口无返回值。
  DBE_STATS.IMPORT_COLUMN_STATS原型为：
  ```
  DBE_STATS.IMPORT_COLUMN_STATS (
     ownname       VARCHAR2, 
     tabname       VARCHAR2, 
     colname       VARCHAR2,
     partname      VARCHAR2 DEFAULT NULL,
     stattab       VARCHAR2, 
     statid        VARCHAR2 DEFAULT NULL,
     statown       VARCHAR2 DEFAULT NULL,
     no_invalidate BOOLEAN DEFAULT NULL,
     force         BOOLEAN DEFAULT FALSE
  );
  ```
  表24DBE_STATS.IMPORT_COLUMN_STATS接口参数说明 
  | 参数            | 类型        | 是否允许为空 | 描述                                                       |
  |:---|:---|:---|:---|
  | ownname      | VARCHAR2 | 否      | 指定schema的名称，如果设置为null，会默认使用当前的schema。                  |
  | tabname      | VARCHAR2  | 否    | 指定需要导入统计信息的列所属的表名（表达式对应索引名）。                             |
  | colname     | VARCHAR2  | 否   | 列名或者多列名（tabname为索引时，colname为表达式名）。                      |
  | partname      | VARCHAR2  | 是     | 分区的名称。如果表/索引已分区但是partname为null，则导入全局和分区列/多列/索引表达式统计信息。 |
  | stattab      | VARCHAR2   | 否    | 指定存储统计信息用户表的表名。                                        |
  | statid      | VARCHAR2   | 是      | 指向stattab中统计信息的标识符（可选）。                                |
  | statown      | VARCHAR2 | 是    | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。         |
  | no_invalidate | BOOLEAN    | 是    | 暂不支持。                                                   |
  | force       | BOOLEAN  | 是     | 是否强制导入，忽略锁的状态，默认false。                                 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导入列级的统计信息可查询[PG_STATISTIC](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1257.html)或者[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)。
  
  - 导入多列时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_import;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_import;
  SET
  gaussdb=# CREATE TABLE IF NOT EXISTS t1 (a int, b int, c int);
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t1_expr on t1((a*a), (a+a), (a*b));
  CREATE INDEX
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# ANALYZE t1((a,b));
  ANALYZE
  -- 建立用户统计信息表，先将单列、多列统计信息导出。
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_import', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+---------------------+-------------+----------+-------------+------------
   1 2    | extname_-1308656218 |          -1 |        8 |             | 
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 't1', colname=> 'a', partname => null, stattab => 'export_table', statid => 't1_c');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 'idx_t1_expr', colname => 'expr', stattab => 'export_table', statid => 't1_expr');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 't1', colname=> 'extname_-1308656218', partname => null, stattab => 'export_table', statid => 't1_c');
   export_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT relname,columnname,stadistinct,stakind1,stanumbers1,stavalues1 FROM export_table ORDER BY 1,2;
     relname   |     columnname      | stadistinct | stakind1 | stanumbers1 |     stavalues1      
  -------------+---------------------+-------------+----------+-------------+---------------------
   idx_t1_expr | expr                |          -1 |        2 |             | {10000,22500,62500}
   t1          | a                   |          -1 |        2 |             | {100,150,250}
   t1          | extname_-1308656218 |          -1 |        8 |             | 
  (3 rows)
  -- 再次插入数据，收集统计信息，查看系统表。
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# ANALYZE t1((a,b));
  ANALYZE
  --查看import前列统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 |        stanumbers1        |  stavalues1   
  -----------+-------------+----------+---------------------------+---------------
           1 |         -.5 |        1 | {.333333,.333333,.333333} | {100,150,250}
           2 |         -.5 |        1 | {.333333,.333333,.333333} | {150,300,550}
           3 |    -.166667 |        1 | {1}                       | {1}
  (3 rows)
  --查看import前表达式统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 |        stanumbers1        |     stavalues1     
  -----------+-------------+----------+---------------------------+---------------------
           1 |         -.5 |        1 | {.333333,.333333,.333333} | {10000,22500,62500}
           2 |         -.5 |        1 | {.333333,.333333,.333333} | {200,300,500}
           3 |         -.5 |        1 | {.333333,.333333,.333333} | {30000,37500,82500}
  (3 rows)
  --查看import前的多列统计信息。
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+---------------------+-------------+----------+-------------+------------
   1 2    | extname_-1308656218 |         -.5 |        8 |             | 
  (1 row)
  -- 导入单列、多列统计信息，查看系统表。
  gaussdb=# CALL DBE_STATS.IMPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 't1', colname=> 'a', partname => null, stattab => 'export_table', statid => 't1_c', force => false);
   import_column_stats 
  ---------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.IMPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 'idx_t1_expr', colname=> 'expr', partname => null, stattab => 'export_table', statid => 't1_expr', force => false);
   import_column_stats 
  ---------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.IMPORT_COLUMN_STATS(ownname => 'dbe_stats_import', tabname => 't1', colname=> 'extname_-1308656218', partname => null, stattab => 'export_table', statid => 't1_c', force => false);
   import_column_stats 
  ---------------------
  (1 row)
  --查看import后的列级统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 |        stanumbers1        |  stavalues1   
  -----------+-------------+----------+---------------------------+---------------
           1 |          -1 |        2 |                           | {100,150,250}
           2 |         -.5 |        1 | {.333333,.333333,.333333} | {150,300,550}
           3 |    -.166667 |        1 | {1}                       | {1}
  (3 rows)
  --查看import后的表达式级统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 |        stanumbers1        |     stavalues1
  -----------+-------------+----------+---------------------------+---------------------
           1 |          -1 |        2 |                           | {10000,22500,62500}
           2 |         -.5 |        1 | {.333333,.333333,.333333} | {200,300,500}
           3 |         -.5 |        1 | {.333333,.333333,.333333} | {30000,37500,82500}
  (3 rows)
  --查看import后的多列统计信息。
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+---------------------+-------------+----------+-------------+------------
   1 2    | extname_-1308656218 |          -1 |        8 |             | 
  (1 row)
  -- 删除表、删除命名空间。
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_import;
  DROP SCHEMA
  ```
  

- DBE_STATS.IMPORT_SCHEMA_STATS
  从stattab标识的用户统计信息表中检索指定schema的统计信息，并将其写回系统表中。该接口无返回值。
  DBE_STATS.IMPORT_SCHEMA_STATS原型为：
  ```
  DBE_STATS.IMPORT_SCHEMA_STATS (
     ownname       VARCHAR2,
     stattab       VARCHAR2, 
     statid        VARCHAR2 DEFAULT NULL,
     statown       VARCHAR2 DEFAULT NULL,
     no_invalidate BOOLEAN  DEFAULT NULL,
     force         BOOLEAN DEFAULT FALSE,
     stat_category VARCHAR2 DEFAULT NULL);
  ```
  表25DBE_STATS.IMPORT_SCHEMA_STATS接口参数说明 
  | 参数            | 类型      | 是否允许为空 | 描述                                              |
  |:---|:---|:---|:---|
  | ownname        | VARCHAR2 | 否      | 指定schema的名称，如果设置为null，会默认使用当前的schema。             |
  | stattab         | VARCHAR2    | 否       | 指定存储统计信息用户表的表名。                                  |
  | statid         | VARCHAR2    | 是      | 指向stattab中统计信息的标识符（可选）。                          |
  | statown        | VARCHAR2 | 是       | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用ownname参数的值。 |
  | no_invalidate | BOOLEAN     | 是    | 暂不支持。                                            |
  | force         | BOOLEAN   | 是        | 是否强制导入，忽略锁的状态，默认false。                          |
  | stat_category   | VARCHAR2  | 是       | 暂不支持。                                              |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导入当前用户在指定schema下所有具有权限的表的统计信息，对于无权限的表直接跳过，不报错。
  
  - 当ownname参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_import_schema CASCADE;
  NOTICE:  schema "dbe_stats_import_schema" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_import_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_import_schema;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (3,3);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 创建用户统计信息表，导出schema统计信息
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_import_schema', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_SCHEMA_STATS(
  gaussdb(#     ownname => 'dbe_stats_import_schema',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1'
  gaussdb;
   export_schema_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证: 导出前 reltuples=3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 再次插入数据，收集统计信息
  gaussdb=# INSERT INTO t1 VALUES (4,4);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (5,5);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (6,6);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 验证: 统计信息已更新 reltuples=6
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  gaussdb=# -- 导入schema统计信息
  gaussdb=# CALL DBE_STATS.IMPORT_SCHEMA_STATS(
  gaussdb(#     ownname => 'dbe_stats_import_schema',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1',
  gaussdb(#     force => false
  gaussdb;
   import_schema_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证: 导入后 reltuples恢复为3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_import_schema;
  DROP SCHEMA
  ```
  

- DBE_STATS.IMPORT_DATABASE_STATS
  从stattab标识的用户统计信息表中检索当前database用户表的统计信息，并将其写回系统表中。该接口无返回值。
  DBE_STATS.IMPORT_DATABASE_STATS原型为：
  ```
  DBE_STATS.IMPORT_DATABASE_STATS (
      stattab         VARCHAR2,
      statid          VARCHAR2 DEFAULT NULL,
      statown         VARCHAR2 DEFAULT NULL,
      no_invalidate   BOOLEAN DEFAULT NULL,
      force           BOOLEAN DEFAULT FALSE,
      stat_category   VARCHAR2 DEFAULT NULL
  );
  ```
  表26DBE_STATS.IMPORT_DATABASE_STATS接口参数说明 
  | 参数             | 类型        | 是否允许为空 | 描述                                          |
  |:---|:---|:---|:---|
  | stattab       | VARCHAR2  | 否     | 指定存储统计信息用户表的表名。                              |
  | statid        | VARCHAR2  | 是        | 指向stattab中统计信息的标识符（可选）。                      |
  | statown          | VARCHAR2  | 是      | 指定存储统计信息用户表所在Schema的名称，如果设置为null，会使用当前Schema。 |
  | no_invalidate  | BOOLEAN | 是        | 暂不支持。                                       |
  | force          | BOOLEAN   | 是      | 是否强制导入，忽略锁的状态，默认false。                       |
  | stat_category | VARCHAR2  | 是      | 暂不支持。                                         |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 导入当前用户在指定database下所有具有analyze权限的用户表的统计信息，对于无权限的表直接跳过，不报错。
  
  - 当statown参数值设置为null时使用当前Schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_import_database CASCADE;
  NOTICE:  schema "dbe_stats_import_database" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_import_database;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_import_database;
  SET
  gaussdb=# CREATE TABLE t1(a int, b int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1,1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (2,2);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (3,3);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 创建用户统计信息表，导出database统计信息
  gaussdb=# CALL DBE_STATS.CREATE_STAT_TABLE('dbe_stats_import_database', 'export_table');
   create_stat_table 
  -------------------
  (1 row)
  gaussdb=# CALL DBE_STATS.EXPORT_DATABASE_STATS(
  gaussdb(#     statown => 'dbe_stats_import_database',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1'
  gaussdb;
   export_database_stats 
  -----------------------
  (1 row)
  gaussdb=# -- 验证: 导出前 reltuples=3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 再次插入数据，收集统计信息
  gaussdb=# INSERT INTO t1 VALUES (4,4);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (5,5);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (6,6);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 验证: 统计信息已更新 reltuples=6
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         6
  (1 row)
  gaussdb=# -- 导入database统计信息
  gaussdb=# CALL DBE_STATS.IMPORT_DATABASE_STATS(
  gaussdb(#     statown => 'dbe_stats_import_database',
  gaussdb(#     stattab => 'export_table',
  gaussdb(#     statid => 's1',
  gaussdb(#     force => false
  gaussdb;
   import_database_stats 
  -----------------------
  (1 row)
  gaussdb=# -- 验证: 导入后 reltuples恢复为3
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples 
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP TABLE export_table;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_import_database;
  DROP SCHEMA
  ```
  
- DBE_STATS.SET_COLUMN_STATS
  设置列相关的统计信息，包括设置单列、多列和表达式统计信息。该接口无返回值。
  DBE_STATS.SET_COLUMN_STATS原型为：
  ```
  DBE_STATS.SET_COLUMN_STATS (
      ownname         VARCHAR2, 
      tabname         VARCHAR2, 
      colname         VARCHAR2, 
      partname        VARCHAR2   DEFAULT NULL,
      stattab         VARCHAR2   DEFAULT NULL,
      statid          VARCHAR2   DEFAULT NULL,
      distcnt         NUMBER     DEFAULT NULL,
      density         NUMBER     DEFAULT NULL,
      nullcnt         NUMBER     DEFAULT NULL,
      srec            VARCHAR2   DEFAULT NULL,
      avgclen         NUMBER     DEFAULT NULL,
      flags           NUMBER     DEFAULT NULL,
      statown         VARCHAR2   DEFAULT NULL,
      no_invalidate   BOOLEAN    DEFAULT NULL,
      force           BOOLEAN    DEFAULT FALSE
  );
  ```
  表27DBE_STATS.SET_COLUMN_STATS接口参数说明 
  | 参数             | 类型          | 是否允许为空 | 描述                                                      |
  |:---|:---|:---|:---|
  | ownname        | VARCHAR2 | 否     | 该表所在的schema。如果设置为null，则默认使用当前schema。                    |
  | tabname        | VARCHAR2  | 否      | 表名。                                                     |
  | colname         | VARCHAR2   | 否       | 列名。                                                      |
  | partname      | VARCHAR2   | 是     | 要设置统计信息的表分区的名称。如果表已分区且partname为null，则设置全局级别的列级统计信息。      |
  | stattab        | VARCHAR2    | 是      | 暂不支持此参数。                                                |
  | statid          | VARCHAR2   | 是      | 暂不支持此参数。                                               |
  | distcnt          | NUMBER  | 是        | 设置该列中NDV数量。                                              |
  | density        | NUMBER    | 是      | 暂不支持。                                                 |
  | nullcnt        | NUMBER   | 是      | 设置该列中null值数量。                                          |
  | srec             | VARCHAR2 | 是       | 暂不支持此参数。                                                |
  | avgclen         | NUMBER    | 是     | 设置该列中字段的平均长度（以字节为单位）。                                    |
  | flags          | NUMBER    | 是    | 暂不支持此参数。                                                |
  | statown         | VARCHAR2  | 是      | 暂不支持此参数。                                              |
  | no_invalidate | BOOLEAN   | 是     | 暂不支持此参数。                                                |
  | force          | BOOLEAN   | 是     | 决定统计信息被锁定时的行为。如果为true，则即使列级统计信息被锁定，该过程也会设置值。默认为false。 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 该接口支持设置表达式统计信息，由于表达式的创建依赖于索引，因此当调用该接口设置表达式统计信息时，tabname应该传入该索引的名称。
  
  - 当前仅支持设置列的NDV（distcnt）、nullfrac（nullcnt）和width（avgclen）三类统计信息。
  
  - 当单列、表达式统计信息被删除后，仍然支持调用该接口设置对应的单列、表达式统计信息，此时[PG_STATISTIC](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1257.html)系统表中将插入新的数据。但对于多列统计信息，当其被删除后，不支持使用该接口进行重新设置。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
  
  - 当前列的行数(reltuples)为0时，nullfrac将会被设置为0，distcnt将会被设置为入参的值。
   
  示例：
  ```
  -- 前置条件，建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_set_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_set_schema;
  SET
  gaussdb=# DROP TABLE IF EXISTS t1;
  NOTICE:  table "t1" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE IF NOT EXISTS t1 (a int, b int, c int);
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t1_expr ON t1((a*a), (a+a), (a*b));
  CREATE INDEX
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# ANALYZE t1((a, b));
  ANALYZE
  -- 设置单列统计信息。
  -- 查询原有统计信息。
  gaussdb=# SELECT staattnum,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1;
   staattnum | stanullfrac | stawidth | stadistinct 
  -----------+-------------+----------+-------------
           1 |           0 |        4 |        -.75
           2 |           0 |        4 |        -.75
           3 |           0 |        4 |        -.25
  (3 rows)
  -- 设置列级统计信息后重新查询。
  gaussdb=# CALL DBE_STATS.SET_COLUMN_STATS(ownname => 'dbe_stats_set_schema', tabname => 't1', colname => 'a', distcnt => 6, nullcnt => 5, avgclen => 42);
   set_column_stats 
  ------------------
  (1 row)
  gaussdb=# SELECT staattnum,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC WHERE starelid='t1'::REGCLASS ORDER BY 1;
   staattnum | stanullfrac | stawidth | stadistinct 
  -----------+-------------+----------+-------------
           1 |           1 |       42 |           6
           2 |           0 |        4 |        -.75
           3 |           0 |        4 |        -.25
  (3 rows)
  -- 设置多列统计信息。
  -- 查询原有统计信息。
  gaussdb=# SELECT stakey,staextname,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stanullfrac | stawidth | stadistinct 
  --------+---------------------+-------------+----------+-------------
   1 2    | extname_-1308656218 |           0 |        8 |        -.75
  (1 row)
  -- 设置统计信息后重新查询
  gaussdb=# CALL DBE_STATS.SET_COLUMN_STATS(ownname => 'dbe_stats_set_schema', tabname => 't1', colname => 'extname_-1308656218', distcnt => 5, nullcnt => 5, avgclen => 2);
   set_column_stats 
  ------------------
  (1 row)
  gaussdb=# SELECT stakey,staextname,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC_EXT WHERE starelid='t1'::REGCLASS;
   stakey |     staextname      | stanullfrac | stawidth | stadistinct 
  --------+---------------------+-------------+----------+-------------
   1 2    | extname_-1308656218 |           1 |        2 |           5
  (1 row)
  -- 设置表达式统计信息。
  -- 查询原有统计信息。
  gaussdb=# SELECT staattnum,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC WHERE starelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   staattnum | stanullfrac | stawidth | stadistinct 
  -----------+-------------+----------+-------------
           1 |           0 |        4 |        -.75
           2 |           0 |        4 |        -.75
           3 |           0 |        4 |        -.75
  (3 rows)
  -- 查询表达式列名。
  gaussdb=# SELECT attnum, attname FROM PG_ATTRIBUTE WHERE attrelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   attnum | attname
  --------+---------
        1 | expr
        2 | expr1
        3 | expr2
  (3 rows)
  -- 设置统计信息后重新查询。
  gaussdb=# CALL DBE_STATS.SET_COLUMN_STATS(ownname => 'dbe_stats_set_schema', tabname => 'idx_t1_expr', colname => 'expr', distcnt => 13, nullcnt => 5, avgclen => 22);
   set_column_stats 
  ------------------
  (1 row)
  gaussdb=# SELECT staattnum,stanullfrac,stawidth,stadistinct FROM PG_STATISTIC WHERE starelid='idx_t1_expr'::REGCLASS ORDER BY 1;
   staattnum | stanullfrac | stawidth | stadistinct 
  -----------+-------------+----------+-------------
           1 |           1 |       22 |          13
           2 |           0 |        4 |        -.75
           3 |           0 |        4 |        -.75
  (3 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP INDEX idx_t1_expr;
  DROP INDEX
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_set_schema cascade;
  DROP SCHEMA
  ```
  

- DBE_STATS.SET_INDEX_STATS
  设置索引相关的统计信息。该接口无返回值。
  DBE_STATS.SET_INDEX_STATS原型为：
  ```
  DBE_STATS.SET_INDEX_STATS (
      ownname       VARCHAR2,
      indname       VARCHAR2,
      partname      VARCHAR2  DEFAULT NULL,
      stattab       VARCHAR2  DEFAULT NULL,
      statid        VARCHAR2  DEFAULT NULL,
      numrows       NUMBER    DEFAULT NULL,
      numlblks      NUMBER    DEFAULT NULL,
      relallvisible NUMBER    DEFAULT NULL,
      numdist       NUMBER    DEFAULT NULL,
      avglblk       NUMBER    DEFAULT NULL,
      avgdblk       NUMBER    DEFAULT NULL,
      clstfct       NUMBER    DEFAULT NULL,
      indlevel      NUMBER    DEFAULT NULL,
      flags         NUMBER    DEFAULT NULL,
      statown       VARCHAR2  DEFAULT NULL,
      no_invalidate BOOLEAN   DEFAULT NULL,
      guessq        NUMBER    DEFAULT NULL,
      cachedblk     NUMBER    DEFAULT NULL,
      cachehit      NUMBER    DEFAULT NULL,
      force         BOOLEAN   DEFAULT FALSE
  );
  ```
  表28DBE_STATS.SET_INDEX_STATS接口参数说明 
  | 参数            | 类型         | 是否允许为空 | 描述                                                   |
  |:---|:---|:---|:---|
  | ownname        | VARCHAR2  | 否         | 该索引所在的schema。如果设置为null，则默认使用当前schema。              |
  | indname      | VARCHAR2  | 否         | 索引名。                                                 |
  | partname      | VARCHAR2   | 是       | 要设置统计信息的索引分区的名称。如果索引已分区且partname为null，则设置全局索引级别的统计信息。  |
  | stattab       | VARCHAR2   | 是       | 暂不支持该参数。                                              |
  | statid        | VARCHAR2   | 是         | 暂不支持该参数。                                            |
  | numrows       | NUMBER     | 是        | 设置索引的行数。                                             |
  | numlblks        | NUMBER    | 是         | 设置索引的页数。                                             |
  | relallvisible  | NUMBER   | 是        | 设置被标识为全可见的索引中的页的数量。                                 |
  | numdist         | NUMBER   | 是       | 暂不支持该参数。                                              |
  | avglblk          | NUMBER    | 是       | 暂不支持此参数。                                            |
  | avgdblk       | NUMBER   | 是        | 暂不支持此参数。                                             |
  | clstfct        | NUMBER   | 是       | 暂不支持此参数。                                             |
  | indlevel       | NUMBER   | 是      | 暂不支持此参数。                                              |
  | flags           | NUMBER     | 是        | 暂不支持此参数。                                             |
  | statown        | VARCHAR2   | 是       | 暂不支持此参数。                                             |
  | no_invalidate | BOOLEAN | 是        | 暂不支持此参数。                                            |
  | guessq          | NUMBER    | 是         | 暂不支持此参数。                                              |
  | cachedblk       | NUMBER   | 是         | 暂不支持此参数。                                             |
  | cachehit       | NUMBER  | 是        | 暂不支持此参数。                                            |
  | force           | BOOLEAN    | 是         | 决定统计信息被锁定时的行为。如果为TRUE，则即使索引统计信息被锁定，该过程也会设置值。默认为false。 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 当前仅支持设置索引的reltuples（numrows）、relpages（numlblks）和relallvisible（relallvisible）三类统计信息。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 前置条件，建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_set_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_set_schema;
  SET
  gaussdb=# DROP TABLE IF EXISTS t1;
  NOTICE:  table "t1" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE IF NOT EXISTS t1 (a int, b int, c int);
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t1_a on t1(a);
  CREATE INDEX
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  -- 设置索引统计信息。
  -- 查看当前索引统计信息。
  gaussdb=# SELECT reltuples,relpages,relallvisible FROM PG_CLASS WHERE relname='idx_t1_a';
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
           3 |        2 |             0
  (1 row)
  -- 设置统计信息后重新查询。
  gaussdb=# CALL DBE_STATS.SET_INDEX_STATS(indname => 'idx_t1_a', ownname => 'dbe_stats_set_schema', numrows => 1, numlblks => 3, relallvisible => 6);
   set_index_stats 
  -----------------
  (1 row)
  gaussdb=# SELECT reltuples,relpages,relallvisible FROM PG_CLASS WHERE relname='idx_t1_a';
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
           1 |        3 |             6
  (1 row)
  -- 删除表、命名空间。
  gaussdb=# DROP INDEX idx_t1_a;
  DROP INDEX
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_set_schema CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.SET_TABLE_STATS
  设置表级统计信息。该接口无返回值。
  DBE_STATS.SET_TABLE_STATS原型为：
  ```
  DBE_STATS.SET_TABLE_STATS (
      ownname         VARCHAR2, 
      tabname         VARCHAR2, 
      partname        VARCHAR2 DEFAULT NULL,
      stattab        VARCHAR2  DEFAULT NULL,
      statid         VARCHAR2  DEFAULT NULL,
      numrows        NUMBER    DEFAULT NULL, 
      numblks        NUMBER    DEFAULT NULL,
      relallvisible  NUMBER    DEFAULT NULL,
      avgrlen        NUMBER    DEFAULT NULL,
      flags          NUMBER    DEFAULT NULL,
      statown        VARCHAR2  DEFAULT NULL,
      no_invalidate  BOOLEAN   DEFAULT NULL,
      cachedblk      NUMBER    DEFAULT NULL,
      cachehit       NUMBER    DEFAULT NULL,
      force          BOOLEAN   DEFAULT FALSE,
      im_imcu_count  NUMBER    DEFAULT NULL,
      im_block_count NUMBER    DEFAULT NULL,
      scanrate       NUMBER    DEFAULT NULL
  );
  ```
  表29DBE_STATS.SET_TABLE_STATS接口参数说明 
  | 参数               | 类型         | 是否允许为空 | 描述                                                  |
  |:---|:---|:---|:---|
  | ownname         | VARCHAR2 | 否       | 该表所在的schema。如果设置为null，则默认使用当前schema。                 |
  | tabname      | VARCHAR2   | 否       | 表名。                                                  |
  | partname     | VARCHAR2  | 是        | 要设置统计信息的表分区的名称。如果表已分区且partname为null，则设置全局表级别的统计信息。 |
  | stattab        | VARCHAR2 | 是     | 暂不支持该参数。                                           |
  | statid        | VARCHAR2    | 是      | 暂不支持该参数。                                           |
  | numrows       | NUMBER   | 是      | 设置表的行数。                                            |
  | numblks        | NUMBER    | 是      | 设置表的页数。                                            |
  | relallvisible   | NUMBER    | 是      | 设置被标识为全可见的表中的页的数量。                                  |
  | avgrlen        | NUMBER   | 是     | 暂不支持该参数。                                            |
  | flags         | NUMBER    | 是    | 暂不支持此参数。                                           |
  | statown       | VARCHAR2 | 是     | 暂不支持此参数。                                           |
  | no_invalidate  | BOOLEAN  | 是      | 暂不支持此参数。                                             |
  | cachedblk        | NUMBER     | 是       | 暂不支持此参数。                                           |
  | cachehit        | NUMBER   | 是     | 暂不支持此参数。                                             |
  | force        | BOOLEAN    | 是    | 决定统计信息被锁定时的行为。如果为TRUE，则即使表统计信息被锁定，该过程也会设置值。默认为false。 |
  | im_imcu_count  | NUMBER     | 是      | 暂不支持此参数。                                            |
  | im_block_count | NUMBER    | 是      | 暂不支持此参数。                                            |
  | scanrate        | NUMBER   | 是      | 暂不支持此参数。                                             |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 当前仅支持设置表的reltuples（numrows）、relpages（numblks）和relallvisible（relallvisible）三类统计信息。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_set_schema_table CASCADE;
  NOTICE:  schema "dbe_stats_set_schema_table" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 前置条件，建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_set_schema_table;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_set_schema_table;
  SET
  gaussdb=# DROP TABLE IF EXISTS t1;
  NOTICE:  table "t1" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE IF NOT EXISTS t1 (a int, b int, c int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 查看当前表统计信息
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
           3 |        1 |             0
  (1 row)
  gaussdb=# -- 设置表级统计信息 (numrows=10, numblks=3, relallvisible=6)
  gaussdb=# CALL DBE_STATS.SET_TABLE_STATS(
  gaussdb(#     tabname => 't1',
  gaussdb(#     ownname => 'dbe_stats_set_schema_table',
  gaussdb(#     numrows => 10,
  gaussdb(#     numblks => 3,
  gaussdb(#     relallvisible => 6
  gaussdb;
   set_table_stats 
  -----------------
  (1 row)
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
          10 |        3 |             6
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_set_schema_table CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.DELETE_COLUMN_STATS
  删除列相关的统计信息，包括删除单列、多列和表达式统计信息。该接口无返回值。
  DBE_STATS.DELETE_COLUMN_STATS原型为：
  ```
  DBE_STATS.DELETE_COLUMN_STATS (
      ownname        VARCHAR2,
      tabname        VARCHAR2,
      colname        VARCHAR2,
      partname       VARCHAR2 DEFAULT NULL,
      stattab        VARCHAR2 DEFAULT NULL,
      statid         VARCHAR2 DEFAULT NULL,
      cascade_parts  BOOLEAN  DEFAULT TRUE,
      statown        VARCHAR2 DEFAULT NULL,
      no_invalidate  BOOLEAN  DEFAULT NULL,
      force          BOOLEAN  DEFAULT FALSE,
      col_stat_type  VARCHAR2 DEFAULT NULL
  );
  ```
  表30DBE_STATS.DELETE_COLUMN_STATS接口参数说明 
  | 参数            | 类型        | 是否允许为空 | 说明                                                                                          |
  |:---|:---|:---|:---|
  | ownname      | VARCHAR2    | 否      | 该表所在的schema。如果设置为null，则默认使用当前schema。                                                          |
  | tabname       | VARCHAR2 | 否      | 表名。                                                                                          |
  | colname       | VARCHAR2 | 否      | 列名。                                                                                          |
  | partname     | VARCHAR2 | 是     | 要删除统计信息的表分区的名称。如果表已分区且partname为null，则删除全局级别的列级统计信息，并且如果cascade_parts为true，则级联删除所有分区的列级统计信息。 |
  | stattab       | VARCHAR2   | 是      | 暂不支持此参数。                                                                                     |
  | statid        | VARCHAR2  | 是      | 暂不支持此参数。                                                                                     |
  | cascade_parts | BOOLEAN | 是      | 决定在删除列级统计信息时是否将其下面的所有分区的统计信息级联删除。默认为true。                                                     |
  | statown       | VARCHAR2  | 是         | 暂不支持此参数。                                                                                     |
  | no_invalidate | BOOLEAN  | 是       | 暂不支持此参数。                                                                                     |
  | force        | BOOLEAN  | 是        | 决定统计信息被锁定时的行为。如果为true，则即使列统计信息被锁定，该过程也会将其删除。默认为false。                                      |
  | col_stat_type | VARCHAR2   | 是        | 暂不支持此参数。                                                                                     |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 该接口支持删除表达式统计信息，由于表达式的创建依赖于索引，因此当调用该接口删除表达式统计信息时，tabname应该传入该索引的名称。
  
  - 如果表是一个二级分区表，且指定partname为一级分区名，此时如果cascade_parts为true，则会将该一级分区下的所有二级分区统计信息一并删除。
  
  - 删除多列统计信息时，需先查询[PG_STATISTIC_EXT](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/gaussdb-38-1258.html)中的staextname字段获取多列别名作为colname入参传入。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 前置条件，建表，收集统计信息。
  gaussdb=# CREATE SCHEMA dbe_stats_delete_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_delete_schema;
  SET
  gaussdb=# DROP TABLE IF EXISTS t2;
  NOTICE:  table "t2" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE t2(a int, b int, c int) PARTITION BY RANGE(a) SUBPARTITION BY RANGE(b)
   (
      PARTITION p1 VALUES LESS THAN(200)
      (SUBPARTITION s1 VALUES LESS THAN (500),
       SUBPARTITION s2 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p2 VALUES LESS THAN(500)
      (SUBPARTITION s3 VALUES LESS THAN (500),
       SUBPARTITION s4 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p3 VALUES LESS THAN(MAXVALUE)
      ( SUBPARTITION s5 VALUES LESS THAN (500),
        SUBPARTITION s6 VALUES LESS THAN (MAXVALUE)
      ));
  CREATE TABLE
  gaussdb=# INSERT INTO t2 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 400, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 600, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t2 WITH ALL;
  ANALYZE
  gaussdb=# ANALYZE t2((a, b)) WITH ALL;
  ANALYZE
  -- 删除t2表的单列统计信息，不级联分区，分区统计信息仍然存在。
  -- 查看表级列的统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t2'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 |        stanumbers1        |  stavalues1   
  -----------+-------------+----------+---------------------------+---------------
           1 |         -.5 |        1 | {.333333,.333333,.333333} | {100,300,600}
           2 |         -.5 |        1 | {.5,.333333}              | {600,300}
           3 |    -.166667 |        1 | {1}                       | {1}
  (3 rows)
  -- 查看分区级列的统计信息。
  gaussdb=# SELECT part.relname,s.staattnum,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid ORDER BY 1,2;
   relname | staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+-----------+-------------+----------+-------------+------------
   p1      |         1 |          -1 |        1 | {1}         | {100}
   p1      |         2 |          -1 |        2 |             | {300,600}
   p1      |         3 |          -1 |        1 | {1}         | {1}
   p2      |         1 |          -1 |        1 | {1}         | {300}
   p2      |         2 |          -1 |        2 |             | {300,600}
   p2      |         3 |          -1 |        1 | {1}         | {1}
   p3      |         1 |          -1 |        1 | {1}         | {600}
   p3      |         2 |          -1 |        2 |             | {400,600}
   p3      |         3 |          -1 |        1 | {1}         | {1}
  (9 rows)
  -- 删除表级单列统计信息，不级联分区，表级不存在，分区级列的统计信息仍然存在。
  gaussdb=# CALL DBE_STATS.DELETE_COLUMN_STATS(ownname => 'dbe_stats_delete_schema', tabname => 't2', colname => 'a', partname => null, cascade_parts => false);
   delete_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t2'::REGCLASS ORDER BY 1;
   staattnum | stadistinct | stakind1 | stanumbers1  | stavalues1 
  -----------+-------------+----------+--------------+------------
           2 |         -.5 |        1 | {.5,.333333} | {600,300}
           3 |    -.166667 |        1 | {1}          | {1}
  (2 rows)
  gaussdb=# SELECT part.relname,s.staattnum,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid ORDER BY 1,2;
   relname | staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+-----------+-------------+----------+-------------+------------
   p1      |         1 |          -1 |        1 | {1}         | {100}
   p1      |         2 |          -1 |        2 |             | {300,600}
   p1      |         3 |          -1 |        1 | {1}         | {1}
   p2      |         1 |          -1 |        1 | {1}         | {300}
   p2      |         2 |          -1 |        2 |             | {300,600}
   p2      |         3 |          -1 |        1 | {1}         | {1}
   p3      |         1 |          -1 |        1 | {1}         | {600}
   p3      |         2 |          -1 |        2 |             | {400,600}
   p3      |         3 |          -1 |        1 | {1}         | {1}
  (9 rows)
  -- 删除t2表的多列统计信息，级联分区，分区的列级统计信息被同时删除。
  -- 查询统计信息。
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t2'::REGCLASS;
   stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+---------------------+-------------+----------+-------------+------------
   1 2    | extname_-1308656218 |          -1 |        8 |             | 
  (1 row)
  gaussdb=# SELECT part.relname,s.stakey,s.staextname,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC_EXT s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid ORDER BY 1;
   relname | stakey |     staextname      | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+--------+---------------------+-------------+----------+-------------+------------
   p1      | 1 2    | extname_-1308656218 |          -1 |        8 |             | 
   p2      | 1 2    | extname_-1308656218 |          -1 |        8 |             | 
   p3      | 1 2    | extname_-1308656218 |          -1 |        8 |             | 
  (3 rows)
  -- 删除多列统计信息，查询统计信息。
  gaussdb=# CALL DBE_STATS.DELETE_COLUMN_STATS(ownname => 'dbe_stats_delete_schema', tabname => 't2', colname => 'extname_-1308656218', partname => null, cascade_parts => true);
   delete_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT stakey,staextname,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC_EXT WHERE starelid='t2'::REGCLASS;
   stakey | staextname | stadistinct | stakind1 | stanumbers1 | stavalues1 
  --------+------------+-------------+----------+-------------+------------
  (0 rows)
  gaussdb=# SELECT part.relname,s.stakey,s.staextname,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC_EXT s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid;
   relname | stakey | staextname | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+--------+------------+-------------+----------+-------------+------------
  (0 rows)
  -- 指定删除p1分区的列级统计信息，表级、p2、p3列统计信息不受影响。
  -- 查询统计信息。
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t2'::REGCLASS and staattnum=2;
   staattnum | stadistinct | stakind1 | stanumbers1  | stavalues1 
  -----------+-------------+----------+--------------+------------
           2 |         -.5 |        1 | {.5,.333333} | {600,300}
  (1 row)
  gaussdb=# SELECT part.relname,s.staattnum,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid and s.staattnum=2 ORDER BY 1;
   relname | staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+-----------+-------------+----------+-------------+------------
   p1      |         2 |          -1 |        2 |             | {300,600}
   p2      |         2 |          -1 |        2 |             | {300,600}
   p3      |         2 |          -1 |        2 |             | {400,600}
  (3 rows)
  -- 删除p1分区的列统计信息，查询统计信息。
  gaussdb=# CALL DBE_STATS.DELETE_COLUMN_STATS(ownname => 'dbe_stats_delete_schema', tabname => 't2', colname => 'b', partname => 'p1', cascade_parts => false);
   delete_column_stats 
  ---------------------
  (1 row)
  gaussdb=# SELECT staattnum,stadistinct,stakind1,stanumbers1,stavalues1 FROM PG_STATISTIC WHERE starelid='t2'::REGCLASS and staattnum=2;
   staattnum | stadistinct | stakind1 | stanumbers1  | stavalues1 
  -----------+-------------+----------+--------------+------------
           2 |         -.5 |        1 | {.5,.333333} | {600,300}
  (1 row)
  gaussdb=# SELECT part.relname,s.staattnum,s.stadistinct,s.stakind1,s.stanumbers1,s.stavalues1 FROM PG_STATISTIC s,PG_PARTITION part WHERE part.parentid='t2'::REGCLASS and s.starelid=part.oid and s.staattnum=2 ORDER BY 1;
   relname | staattnum | stadistinct | stakind1 | stanumbers1 | stavalues1 
  ---------+-----------+-------------+----------+-------------+------------
   p2      |         2 |          -1 |        2 |             | {300,600}
   p3      |         2 |          -1 |        2 |             | {400,600}
  (2 rows)
  -- 删除表、命名空间。
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_delete_schema CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.DELETE_INDEX_STATS
  删除索引相关的统计信息。该接口无返回值。
  DBE_STATS.DELETE_INDEX_STATS原型为:
  ```
  DBE_STATS.DELETE_INDEX_STATS (
      ownname          VARCHAR2, 
      indname          VARCHAR2,
      partname         VARCHAR2 DEFAULT NULL,
      stattab          VARCHAR2 DEFAULT NULL, 
      statid           VARCHAR2 DEFAULT NULL,
      cascade_parts    BOOLEAN  DEFAULT TRUE,
      statown          VARCHAR2 DEFAULT NULL,
      no_invalidate    BOOLEAN  DEFAULT NULL,
      stattype         VARCHAR2 DEFAULT NULL,
      force            BOOLEAN  DEFAULT FALSE,
      stat_category    VARCHAR2 DEFAULT NULL
  )
  ```
  表31DBE_STATS.DELETE_INDEX_STATS接口参数说明 
  | 参数              | 类型        | 是否允许为空 | 描述                                                                                              |
  |:---|:---|:---|:---|
  | ownname        | VARCHAR2  | 否    | 该索引所在的schema。如果设置为null，则默认使用当前schema。                                                         |
  | indname        | VARCHAR2  | 否     | 索引名。                                                                                          |
  | partname         | VARCHAR2 | 是       | 要删除统计信息的索引分区的名称。如果索引已分区且partname为null，则删除全局级别的索引统计信息，并且如果cascade_parts为true，则级联删除所有分区的索引统计信息。 |
  | stattab         | VARCHAR2 | 是    | 暂不支持此参数。                                                                                        |
  | statid         | VARCHAR2   | 是     | 暂不支持此参数。                                                                                        |
  | cascade_parts  | BOOLEAN  | 是     | 决定在删除索引统计信息时是否将其下面的所有分区的索引统计信息级联删除。默认为true。                                                     |
  | statown       | VARCHAR2  | 是     | 暂不支持此参数。                                                                                      |
  | no_invalidate | BOOLEAN  | 是       | 暂不支持此参数。                                                                                         |
  | stattype       | VARCHAR2 | 是      | 暂不支持此参数。                                                                                     |
  | force            | BOOLEAN    | 是       | 决定统计信息被锁定时的行为。如果为true，则即使索引统计信息被锁定，该过程也会将其删除。默认为false。                                        |
  | stat_category | VARCHAR2   | 是      | 暂不支持此参数。                                                                                       |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 删除索引的统计信息等同于将索引统计信息的reltuples、relpages和relallvisible信息置零。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  -- 前置条件，建表。
  gaussdb=# CREATE SCHEMA dbe_stats_delete_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_delete_schema;
  SET
  gaussdb=# DROP TABLE IF EXISTS t2;
  NOTICE:  table "t2" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE t2(a int, b int, c int) PARTITION BY RANGE(a) SUBPARTITION BY RANGE(b)
   (
      PARTITION p1 VALUES LESS THAN(200)
      (SUBPARTITION s1 VALUES LESS THAN (500),
       SUBPARTITION s2 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p2 VALUES LESS THAN(500)
      (SUBPARTITION s3 VALUES LESS THAN (500),
       SUBPARTITION s4 VALUES LESS THAN (MAXVALUE)
      ),
      PARTITION p3 VALUES LESS THAN(MAXVALUE)
      ( SUBPARTITION s5 VALUES LESS THAN (500),
        SUBPARTITION s6 VALUES LESS THAN (MAXVALUE)
      ));
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t2_local_a ON t2(a) LOCAL
   (
       PARTITION p1_idx_a
       (
           SUBPARTITION s1_idx_a,
           SUBPARTITION s2_idx_a
       ),
       PARTITION p2_idx_a
       (
           SUBPARTITION s3_idx_a,
           SUBPARTITION s4_idx_a
       ),
       PARTITION p3_idx_a
       (
           SUBPARTITION s5_idx_a,
           SUBPARTITION s6_idx_a
       ));
  CREATE INDEX
  gaussdb=# INSERT INTO t2 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (100, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (300, 600, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 400, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t2 VALUES (600, 600, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t2 WITH ALL;
  ANALYZE
  gaussdb=# ANALYZE t2((a, b)) WITH ALL;
  ANALYZE
  -- 删除idx_t2_local_a索引的统计信息，不级联分区索引的统计信息。
  -- 查看统计信息。
  gaussdb=# SELECT relpages,reltuples FROM PG_CLASS WHERE relname='idx_t2_local_a';
   relpages | reltuples 
  ----------+-----------
          6 |         6
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples 
  ----------+----------+-----------
   s1_idx_a |        1 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 删除统计信息，查询系统表。
  gaussdb=# CALL DBE_STATS.DELETE_INDEX_STATS(ownname => 'dbe_stats_delete_schema', indname => 'idx_t2_local_a', partname => null, cascade_parts => false);
   delete_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relpages,reltuples FROM PG_CLASS WHERE relname='idx_t2_local_a';
   relpages | reltuples 
  ----------+-----------
          0 |         0
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples 
  ----------+----------+-----------
   s1_idx_a |        1 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 删除idx_t2_local_a索引的s1_idx_a分区的统计信息。
  gaussdb=# CALL DBE_STATS.DELETE_INDEX_STATS(ownname => 'dbe_stats_delete_schema', indname => 'idx_t2_local_a', partname => 's1_idx_a', cascade_parts => false);
   delete_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY 1;
   relname  | relpages | reltuples
  ----------+----------+-----------
   s1_idx_a |        0 |         0
   s2_idx_a |        1 |         0
   s3_idx_a |        1 |         0
   s4_idx_a |        1 |         0
   s5_idx_a |        1 |         0
   s6_idx_a |        1 |         0
  (6 rows)
  -- 级联删除所有分区的索引统计信息。
  gaussdb=# CALL DBE_STATS.DELETE_INDEX_STATS(ownname => 'dbe_stats_delete_schema', indname => 'idx_t2_local_a', partname => null, cascade_parts => true);
   delete_index_stats 
  --------------------
  (1 row)
  gaussdb=# SELECT relname,relpages,reltuples FROM PG_PARTITION WHERE parentid='idx_t2_local_a'::REGCLASS ORDER BY oid;
   relname  | relpages | reltuples
  ----------+----------+-----------
   s1_idx_a |        0 |         0
   s2_idx_a |        0 |         0
   s3_idx_a |        0 |         0
   s4_idx_a |        0 |         0
   s5_idx_a |        0 |         0
   s6_idx_a |        0 |         0
  (6 rows)
  -- 删表、删除命名空间。
  gaussdb=# DROP INDEX idx_t2_local_a;
  DROP INDEX
  gaussdb=# DROP TABLE t2;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_delete_schema CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.DELETE_TABLE_STATS
  删除表级统计信息。该接口无返回值。
  DBE_STATS.DELETE_TABLE_STATS原型为:
  ```
  DBE_STATS.DELETE_TABLE_STATS (
      ownname               VARCHAR2, 
      tabname               VARCHAR2, 
      partname              VARCHAR2 DEFAULT NULL,
      stattab               VARCHAR2 DEFAULT NULL,
      statid                VARCHAR2 DEFAULT NULL,
      cascade_parts         BOOLEAN  DEFAULT TRUE, 
      cascade_columns       BOOLEAN  DEFAULT TRUE,
      cascade_indexes       BOOLEAN  DEFAULT TRUE,
      statown               VARCHAR2 DEFAULT NULL,
      no_invalidate         BOOLEAN  DEFAULT NULL,
      force                 BOOLEAN  DEFAULT FALSE,
      stat_category         VARCHAR2 DEFAULT NULL
  )
  ```
  表32DBE_STATS.DELETE_TABLE_STATS接口参数说明 
  | 参数                | 类型       | 是否允许为空 | 描述                                                                                        |
  |:---|:---|:---|:---|
  | ownname        | VARCHAR2  | 否     | 该表所在的schema。如果设置为null，则默认使用当前schema。                                                     |
  | tabname          | VARCHAR2    | 否    | 表名。                                                                                      |
  | partname       | VARCHAR2   | 是     | 要删除统计信息的表分区的名称。如果表已分区且partname为null，则删除全局级别的表统计信息，并且如果cascade_parts为true，则级联删除所有分区的表级统计信息。 |
  | stattab       | VARCHAR2 | 是     | 暂不支持此参数。                                                                                  |
  | statid          | VARCHAR2    | 是     | 暂不支持此参数。                                                                                  |
  | cascade_parts    | BOOLEAN     | 是    | 决定在删除表级统计信息时是否将其下面的所有分区的表统计信息级联删除。默认为true。                                               |
  | cascade_columns | BOOLEAN   | 是      | 决定是否调用delete_column_stats删除该表的所有列级统计信息。默认为true。                                           |
  | cascade_indexes | BOOLEAN     | 是     | 决定是否调用delete_index_stats删除该表的所有索引统计信息。默认为true。                                             |
  | statown         | VARCHAR2  | 是     | 暂不支持此参数。                                                                                |
  | no_invalidate   | BOOLEAN     | 是     | 暂不支持此参数。                                                                                  |
  | force           | BOOLEAN    | 是      | 决定统计信息被锁定时的行为。如果为true，则即使表的统计信息被锁定，该过程也会将其删除。默认为false。                                   |
  | stat_category    | VARCHAR2  | 是    | 暂不支持此参数。                                                                                 |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 如果cascade_columns或cascade_indexes设置为true，且是否级联删除对应分区列或索引的统计信息，也由cascade_parts决定。比如，如果cascade_parts设置为true，则对于一个分区表，不仅将其所有分区的表级统计信息删除，而且会将所有分区的列级、索引级统计信息删除。
  
  - 删除表的统计信息等同于将表统计信息的reltuples、relpages和relallvisible信息置零。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_delete_schema_table CASCADE;
  NOTICE:  schema "dbe_stats_delete_schema_table" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 前置条件，建表，建索引，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_delete_schema_table;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_delete_schema_table;
  SET
  gaussdb=# DROP TABLE IF EXISTS t1;
  NOTICE:  table "t1" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE t1(a int, b int, c int);
  CREATE TABLE
  gaussdb=# CREATE INDEX idx_t1_a on t1(a);
  CREATE INDEX
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 查看当前表统计信息
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples  
  ---------+-----------
   t1      |         3
  (1 row)
  gaussdb=# -- 查看当前索引统计信息
  gaussdb=# SELECT reltuples, relpages FROM PG_CLASS WHERE oid='idx_t1_a'::regclass;
   reltuples | relpages 
  -----------+----------
           3 |        2
  (1 row)
  gaussdb=# -- 删除表级统计信息，同时删除列、索引统计信息
  gaussdb=# CALL DBE_STATS.DELETE_TABLE_STATS(
  gaussdb(#     ownname => 'dbe_stats_delete_schema_table',
  gaussdb(#     tabname => 't1',
  gaussdb(#     cascade_indexes => true
  gaussdb;
   delete_table_stats 
  --------------------
  (1 row)
  gaussdb=# -- 验证: 表统计信息已置零 
  gaussdb=# SELECT relname, reltuples FROM PG_CLASS WHERE oid='t1'::regclass;
   relname | reltuples
  ---------+-----------
   t1      |         0
  (1 row)
  gaussdb=# -- 验证: 索引统计信息已置零
  gaussdb=# SELECT reltuples, relpages FROM PG_CLASS WHERE oid='idx_t1_a'::regclass;
   reltuples | relpages 
  -----------+----------
           0 |        0
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_delete_schema_table CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.DELETE_SCHEMA_STATS
  删除schema下所有的表级、索引级和列级统计信息。该接口无返回值。
  DBE_STATS.DELETE_SCHEMA_STATS原型为:
  ```
  DBE_STATS.DELETE_SCHEMA_STATS (
      ownname          VARCHAR2, 
      stattab          VARCHAR2 DEFAULT NULL, 
      statid           VARCHAR2 DEFAULT NULL,
      statown          VARCHAR2 DEFAULT NULL,
      no_invalidate    BOOLEAN  DEFAULT NULL,
      force            BOOLEAN  DEFAULT FALSE,
      stat_category    VARCHAR2 DEFAULT NULL
  );
  ```
  表33DBE_STATS.DELETE_SCHEMA_STATS接口参数说明 
  | 参数            | 类型       | 是否允许为空 | 描述                                                    |
  |:---|:---|:---|:---|
  | ownname      | VARCHAR2  | 否        | schema名字。如果设置为null，则默认使用当前schema。                     |
  | stattab        | VARCHAR2 | 是       | 暂不支持此参数。                                               |
  | statid         | VARCHAR2  | 是        | 暂不支持此参数。                                               |
  | statown       | VARCHAR2  | 是     | 暂不支持此参数。                                            |
  | no_invalidate | BOOLEAN | 是      | 暂不支持此参数。                                           |
  | force          | BOOLEAN   | 是      | 决定统计信息被锁定时的行为。如果为true，则即使有统计信息被锁定，该过程也会将其删除。默认为false。 |
  | stat_category | VARCHAR2 | 是        | 暂不支持此参数。                                             |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 删除schema下的统计信息，即删除当前用户在指定schema下所有有权限的表，对于没有权限的表直接跳过，不报错。
  
  - 当ownname参数值设置为null时使用当前schema，需将behavior_compat_options参数值设置为bind_procedure_searchpath。
   
  示例：
  ```
  gaussdb=# DROP SCHEMA IF EXISTS dbe_stats_delete_schema_schema CASCADE;
  NOTICE:  schema "dbe_stats_delete_schema_schema" does not exist, skipping
  DROP SCHEMA
  gaussdb=# -- 前置条件，建表，收集统计信息
  gaussdb=# CREATE SCHEMA dbe_stats_delete_schema_schema;
  CREATE SCHEMA
  gaussdb=# SET CURRENT_SCHEMA = dbe_stats_delete_schema_schema;
  SET
  gaussdb=# DROP TABLE IF EXISTS t1;
  NOTICE:  table "t1" does not exist, skipping
  DROP TABLE
  gaussdb=# CREATE TABLE t1(a int, b int, c int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (100, 300, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (150, 550, 1);
  INSERT 0 1
  gaussdb=# INSERT INTO t1 VALUES (250, 150, 1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# -- 查看当前表统计信息
  gaussdb=# SELECT reltuples, relpages, relallvisible FROM PG_CLASS WHERE oid='t1'::regclass;
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
           3 |        1 |             0
  (1 row)
  gaussdb=# -- 查看当前列统计信息
  gaussdb=# SELECT count(*) AS col_stats_count FROM PG_STATISTIC WHERE starelid='t1'::regclass;
   col_stats_count 
  -----------------
                 3
  (1 row)
  gaussdb=# -- 删除schema下所有统计信息
  gaussdb=# CALL DBE_STATS.DELETE_SCHEMA_STATS(ownname => 'dbe_stats_delete_schema_schema');
   delete_schema_stats 
  ---------------------
  (1 row)
  gaussdb=# -- 验证: 表统计信息已置零
  gaussdb=# SELECT reltuples, relpages, relallvisible FROM PG_CLASS WHERE oid='t1'::regclass;
   reltuples | relpages | relallvisible 
  -----------+----------+---------------
           0 |        0 |             0
  (1 row)
  gaussdb=# -- 验证: 列统计信息已删除
  gaussdb=# SELECT count(*) AS col_stats_count FROM PG_STATISTIC WHERE starelid='t1'::regclass;
   col_stats_count 
  -----------------
                 0
  (1 row)
  gaussdb=# -- 清理
  gaussdb=# DROP TABLE t1;
  DROP TABLE
  gaussdb=# DROP SCHEMA dbe_stats_delete_schema_schema CASCADE;
  DROP SCHEMA
  ```
  

- DBE_STATS.GET_TABLES_BY_SQLID
  获取Unique SQL ID对应语句所有涉及的表，如果含有多张表，则返回多行记录。
  DBE_STATS.GET_TABLES_BY_SQLID原型为：
  ```
  DBE_STATS.GET_TABLES_BY_SQLID (
      unique_sqlid    BIGINT
  )
  RETURNS TABLE (
      nspname TEXT,
      tabname TEXT
  );
  ```
  表34DBE_STATS.GET_TABLES_BY_SQLID接口参数与返回值说明 
  | 字段名          | 数据类型   | 字段类型 | 是否允许为空 | 描述                                                                                                                                 |
  |:---|:---|:---|:---|:---|
  | unique_sqlid | BIGINT | IN  | 否      | 唯一SQL ID，可从pg_catalog.pg_stat_activity（实时会话信息视图）、dbe_perf.statement（归一化SQL语句记录视图）、dbe_perf.statement_history（全量或慢SQL语句记录视图）中查询获得。 |
  | nspname        | TEXT      | OUT     | 否       | 语句中涉及表的模式名称。                                                                                                                       |
  | tabname       | TEXT     | OUT | 否         | 语句中涉及表的名称。                                                                                                                          |
     
  示例：
  ```
  -- 前置条件。
  gaussdb=# DROP TABLE IF EXISTS t1;
  DROP TABLE
  gaussdb=# CREATE TABLE t1 (c1 int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1);
  INSERT 0 1
  gaussdb=# CREATE OR REPLACE PROCEDURE select_t1()
  gaussdb-# AS
  gaussdb$# BEGIN
  gaussdb$#     PERFORM * FROM t1;
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# DROP TABLE IF EXISTS t2;
  DROP TABLE
  gaussdb=# CREATE TABLE t2 (c1 int) PARTITION BY LIST (c1) (
  gaussdb,
  gaussdb
  gaussdb;
  CREATE TABLE
  gaussdb=# INSERT INTO t2 VALUES (1), (2);
  INSERT 0 2
  gaussdb=# ANALYZE t2;
  ANALYZE
  -- 1.使用从pg_stat_activity中查询的unique sqlid。
  -- 会话1：模拟无法执行的语句。
  gaussdb=# SET cursor_sharing = off; -- 避免自动参数化不进行解析。
  SET
  gaussdb=# SELECT pg_sleep(60) FROM t1;
   pg_sleep 
  ----------
  (1 row)
  -- 会话2：在会话一执行期间查询其unique sqlid，并查询对应的tabname，语句需根据实际sql_id调整。
  gaussdb=#  SELECT query, sessionid, unique_sql_id FROM pg_stat_activity WHERE query LIKE '%pg_sleep%t1%' AND query NOT LIKE '%pg_stat_activity%';
              query             | sessionid | unique_sql_id 
  ------------------------------+-----------+---------------
   SELECT pg_sleep(60) FROM t1; |         1 |    3101300097
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(3101300097);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  -- 2.使用从dbe_perf.statement中查询的unique sqlid。
  gaussdb=# SHOW instr_unique_sql_count; -- 查看statement视图中的最大记录数。
   instr_unique_sql_count 
  ------------------------
   200000
  (1 row)
  gaussdb=# SELECT count(*) FROM dbe_perf.statement; -- 确认statement视图中的记录数是否超限。
   count 
  -------
      46
  (1 row)
  gaussdb=# SELECT reset_unique_sql('GLOBAL','ALL',0); -- 如果达到限制，后续的语句不会再记录，可以清空记录（注：会导致SQL记录丢失）。
   reset_unique_sql 
  ------------------
   t
  (1 row)
  gaussdb=# SELECT * FROM t1;
   c1 
  ----
    1
  (1 row)
  gaussdb=# SELECT unique_sql_id FROM dbe_perf.statement WHERE query LIKE '%SELECT * FROM t1%';
   unique_sql_id 
  ---------------
      4115569441
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(4115569441);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  -- 3.使用从dbe_stats.statement_history中查询的unique sqlid。
  gaussdb=# SET log_min_duration_statement = '1s'; -- 执行时间>=1s的慢SQL会被记录。
  SET
  gaussdb=# DELETE FROM pg_catalog.statement_history; -- 避免受残留的慢SQL记录影响。
  DELETE 2
  gaussdb=# SELECT pg_sleep(1) FROM t1;
   pg_sleep 
  ----------
  (1 row)
  gaussdb=# SELECT unique_query_id FROM dbe_perf.statement_history WHERE query LIKE '%pg_sleep%t1%' LIMIT 1;
   unique_query_id 
  -----------------
        3101300097
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(3101300097);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  -- 4.使用存储过程的unique sqlid，从dbe_stats.statement中查询。
  gaussdb=# SHOW instr_unique_sql_track_type; -- 确认此时statement视图记录包括存储过程子语句。
   instr_unique_sql_track_type 
  -----------------------------
   all
  (1 row)
  gaussdb=# SELECT * FROM select_t1();
   select_t1 
  -----------
  (1 row)
  gaussdb=# SELECT s1.query, s1.unique_sql_id FROM dbe_perf.statement s1 WHERE s1.query = 'SELECT * FROM select_t1();'
  gaussdb-# UNION ALL
  gaussdb-# SELECT s2.query, s2.unique_sql_id FROM dbe_perf.statement s1, dbe_perf.statement s2 WHERE s1.query = 'SELECT * FROM select_t1();' AND s1.unique_sql_id = s2.parent_unique_sql_id;
             query            | unique_sql_id 
  ----------------------------+---------------
   SELECT * FROM select_t1(); |    1861705880
   SELECT * FROM t1           |    4115569441
  (2 rows)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(1861705880); -- 顶层语句不包含基表。
   nspname | tabname 
  ---------+---------
  (0 rows)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(4115569441); -- 子语句包含基表。
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  -- 5.在dbe_perf.statement中查询，涉及多张表的语句。
  gaussdb=# SELECT * FROM t1, t2 LIMIT 1;
   c1 | c1 
  ----+----
    1 |  1
  (1 row)
  gaussdb=# SELECT query, unique_sql_id FROM dbe_perf.statement WHERE query LIKE '%SELECT * FROM t1, t2 LIMIT%';
               query             | unique_sql_id 
  -------------------------------+---------------
   SELECT * FROM t1, t2 LIMIT ?; |    2763456878
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.get_tables_by_sqlid(2763456878);
   nspname | tabname 
  ---------+---------
   public  | t1
   public  | t2
  (2 rows)
  -- 后置操作。
  gaussdb=# DROP PROCEDURE IF EXISTS select_t1;
  DROP PROCEDURE
  gaussdb=# DROP TABLE IF EXISTS t1;
  DROP TABLE
  gaussdb=# DROP TABLE IF EXISTS t2;
  DROP TABLE
  ```
  
- DBE_STATS.ANALYZE_SQLID
  获取Unique SQL ID对应语句所有涉及的表，以及收集对应表的统计信息。对于收集成功的表，如果含有多张表，则返回多行记录。
  DBE_STATS.ANALYZE_SQLID原型为：
  ```
  DBE_STATS.ANALYZE_SQLID (
      unique_sqlid    BIGINT,
      all_complete    BOOLEAN DEFAULT FALSE
  )
  RETURNS TABLE (
      
      nspname TEXT,
      tabname TEXT
  );
  ```
  表35DBE_STATS.ANALYZE_SQLID接口参数与返回值说明 
  | 字段名           | 数据类型 | 字段类型 | 是否允许为空 | 描述                                                                                                                             |
  |:---|:---|:---|:---|:---|
  | unique_sqlid | BIGINT | IN | 否       | 唯一SQL ID，可从pg_catalog.pg_stat_activity（实时会话信息视图）、dbe_perf.statement（归一化SQL语句记录视图）、dbe_perf.statement_history（全量或慢SQL语句记录视图）中查询获得。 |
  | all_complete    | BOOLEAN | IN   | 是        | 指定是否使用ALL COMPLETE模式进行统计信息收集，与ANALYZE tabname WITH ALL COMPLETE的行为一致。未指定则使用默认模式，对应ANALYZE tabname。                                 |
  | nspname     | TEXT   | OUT | 否       | 语句中涉及表的模式名称。                                                                                                                    |
  | tabname     | TEXT    | OUT  | 否       | 语句中涉及表的名称。仅包含成功收集统计信息的表。                                                                                                         |
     
  示例：
  ```
  -- ANALYZE_SQLID的使用方法与上述GET_TABLES_SQLID基本相同，除了本接口会实际收集统计信息，以及提供了all_complete选项。
  -- 前置条件。
  gaussdb=# DROP TABLE IF EXISTS t1;
  DROP TABLE
  gaussdb=# CREATE TABLE t1 (c1 int);
  CREATE TABLE
  gaussdb=# INSERT INTO t1 VALUES (1);
  INSERT 0 1
  gaussdb=# ANALYZE t1;
  ANALYZE
  gaussdb=# CREATE OR REPLACE PROCEDURE select_t1()
  gaussdb-# AS
  gaussdb$# BEGIN
  gaussdb$#     PERFORM * FROM t1;
  gaussdb$# END;
  gaussdb$# /
  CREATE PROCEDURE
  gaussdb=# DROP TABLE IF EXISTS t2;
  DROP TABLE
  gaussdb=# CREATE TABLE t2 (c1 int) PARTITION BY LIST (c1) (
  gaussdb,
  gaussdb
  gaussdb;
  CREATE TABLE
  gaussdb=# INSERT INTO t2 VALUES (1), (2);
  INSERT 0 2
  gaussdb=# ANALYZE t2;
  ANALYZE
  -- 1.使用从pg_stat_activity中查询的unique sqlid。
  -- 会话1：模拟无法执行的语句。
  gaussdb=# SET cursor_sharing = off; -- 避免自动参数化不进行解析。
  SET
  gaussdb=# SELECT pg_sleep(60) FROM t1;
   pg_sleep 
  ----------
  (1 row)
  -- 会话2：在会话一执行期间查询其unique sqlid，并查询对应的tabname，语句需根据实际sql_id调整。
  gaussdb=#  SELECT query, sessionid, unique_sql_id FROM pg_stat_activity WHERE query LIKE '%pg_sleep%t1%' AND query NOT LIKE '%pg_stat_activity%';
              query             | sessionid | unique_sql_id 
  ------------------------------+-----------+---------------
   SELECT pg_sleep(60) FROM t1; |         1 |    3101300097
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 此前的analyze次数。
   analyze_count 
  ---------------
               1
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(3101300097);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 确认以上操作完成了一次analyze。
   analyze_count 
  ---------------
               2
  (1 row)
  -- 2.使用从dbe_perf.statement中查询的unique sqlid。
  gaussdb=# SHOW instr_unique_sql_count; -- 查看statement视图中的最大记录数。
   instr_unique_sql_count 
  ------------------------
   200000
  (1 row)
  gaussdb=# SELECT count(*) FROM dbe_perf.statement; -- 确认statement视图中的记录数是否超限。
   count 
  -------
      46
  (1 row)
  gaussdb=# SELECT reset_unique_sql('GLOBAL','ALL',0); -- 如果达到限制，后续的语句不会再记录，可以清空记录（注：会导致SQL记录丢失）。
   reset_unique_sql 
  ------------------
   t
  (1 row)
  gaussdb=# SELECT * FROM t1;
   c1 
  ----
    1
  (1 row)
  gaussdb=# SELECT unique_sql_id FROM dbe_perf.statement WHERE query LIKE '%SELECT * FROM t1%';
   unique_sql_id 
  ---------------
      4115569441
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 此前的analyze次数。
   analyze_count 
  ---------------
               2
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(4115569441);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 确认以上操作完成了一次analyze。
   analyze_count 
  ---------------
               3
  (1 row)
  -- 3.使用从dbe_stats.statement_history中查询的unique sqlid。
  gaussdb=# SET log_min_duration_statement = '1s'; -- 执行时间>=1s的慢SQL会被记录。
  SET
  gaussdb=# DELETE FROM pg_catalog.statement_history; -- 避免受残留的慢SQL记录影响。
  DELETE 2
  gaussdb=# SELECT pg_sleep(1) FROM t1;
   pg_sleep 
  ----------
  (1 row)
  gaussdb=# SELECT unique_query_id FROM dbe_perf.statement_history WHERE query LIKE '%pg_sleep%t1%' LIMIT 1;
   unique_query_id 
  -----------------
        3101300097
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 此前的analyze次数。
   analyze_count 
  ---------------
               3
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(3101300097);
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 确认以上操作完成了一次analyze。
   analyze_count 
  ---------------
               4
  (1 row)
  -- 4.使用存储过程的unique sqlid，从dbe_stats.statement中查询。
  gaussdb=# SHOW instr_unique_sql_track_type; -- 确认此时statement视图记录包括存储过程子语句。
   instr_unique_sql_track_type 
  -----------------------------
   all
  (1 row)
  gaussdb=# SELECT * FROM select_t1();
   select_t1 
  -----------
  (1 row)
  gaussdb=# SELECT s1.query, s1.unique_sql_id FROM dbe_perf.statement s1 WHERE s1.query = 'SELECT * FROM select_t1();'
  gaussdb-# UNION ALL
  gaussdb-# SELECT s2.query, s2.unique_sql_id FROM dbe_perf.statement s1, dbe_perf.statement s2 WHERE s1.query = 'SELECT * FROM select_t1();' AND s1.unique_sql_id = s2.parent_unique_sql_id;
             query            | unique_sql_id 
  ----------------------------+---------------
   SELECT * FROM select_t1(); |    1861705880
   SELECT * FROM t1           |    4115569441
  (2 rows)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 此前的analyze次数。
   analyze_count 
  ---------------
               4
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(1861705880); -- 顶层语句不包含基表。
   nspname | tabname 
  ---------+---------
  (0 rows)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 以上操作并没有触发t1表的analyze。
   analyze_count 
  ---------------
               4
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(4115569441); -- 子语句包含基表。
   nspname | tabname 
  ---------+---------
   public  | t1
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't1'; -- 确认以上操作完成了一次analyze。
   analyze_count 
  ---------------
               5
  (1 row)
  -- 5.查询dbe_perf.statement，并对分区表使用all_complete模式进行统计信息收集。
  gaussdb=# SELECT * FROM t2;
   c1 
  ----
    1
    2
  (2 rows)
  gaussdb=# SELECT query, unique_sql_id FROM dbe_perf.statement WHERE query LIKE '%SELECT * FROM t2%';
         query       | unique_sql_id 
  -------------------+---------------
   SELECT * FROM t2; |     909667705
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't2'; -- 此前的analyze次数。
   analyze_count 
  ---------------
               1
  (1 row)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(909667705, true); -- 使用all_complete模式，每个分区会采集更大的样本。
   nspname | tabname 
  ---------+---------
   public  | t2
  (1 row)
  gaussdb=# SELECT analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname = 't2'; -- 确认以上操作完成了一次analyze。
   analyze_count 
  ---------------
               2
  (1 row)
  -- 6.在dbe_perf.statement中查询并收集，涉及多张表的语句。
  gaussdb=# SELECT * FROM t1, t2 LIMIT 1;
   c1 | c1 
  ----+----
    1 |  1
  (1 row)
  gaussdb=# SELECT query, unique_sql_id FROM dbe_perf.statement WHERE query LIKE '%SELECT * FROM t1, t2 LIMIT%';
               query             | unique_sql_id 
  -------------------------------+---------------
   SELECT * FROM t1, t2 LIMIT ?; |    2763456878
  (1 row)
  gaussdb=# SELECT relname, analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname IN ('t1', 't2');
   relname | analyze_count 
  ---------+---------------
   t1      |             5
   t2      |             2
  (2 rows)
  gaussdb=# SELECT * FROM dbe_stats.analyze_sqlid(2763456878);
   nspname | tabname 
  ---------+---------
   public  | t1
   public  | t2
  (2 rows)
  gaussdb=# SELECT relname, analyze_count FROM pg_stat_all_tables WHERE schemaname = 'public' AND relname IN ('t1', 't2');
   relname | analyze_count 
  ---------+---------------
   t1      |             6
   t2      |             3
  (2 rows)
  -- 后置操作。
  gaussdb=# DROP PROCEDURE IF EXISTS select_t1;
  DROP PROCEDURE
  gaussdb=# DROP TABLE IF EXISTS t1;
  DROP TABLE
  gaussdb=# DROP TABLE IF EXISTS t2;
  DROP TABLE
  ```
  

- dbe_stats_tools.py
  该python脚本用于简化库级统计信息的导出和导入流程：
  - 导出统计信息时，需要具备相应的接口或命令（DBE_STATS.CREATE_STAT_TABLE、DBE_STATS.EXPORT_DATABASE_STATS、\\COPY TO、DBE_STATS.DROP_STAT_TABLE）的权限，以及指定导出目录的读写权限。
  
  - 导入统计信息时，需要具备相应接口或命令（DBE_STATS.CREATE_STAT_TABLE、DBE_STATS.EXPORT_DATABASE_STATS、\\COPY FROM、DBE_STATS.DROP_STAT_TABLE）的权限，以及指定导出目录下文件的读取权限。
  
  - 导出语句元信息的收集项包括：
    - 输入的SQL语句文本。
    
    - 在hint生效与不生效场景下，对SQL语句执行EXPLAIN的结果。
    
    - 在hint生效与不生效场景下，SQL语句计划生成过程中的PLAN TRACE信息。
    
    - 所在DATABASE中所有对象的定义。
    
    - 与计划调优相关的所有GUC参数配置，该不包含应用的会话级别配置。
    
    - SQL语句所引用表对象的当前统计信息与历史统计信息。M-Compatibility兼容模式下无历史统计信息。
    
    
    导出语句元信息时，需要数据库的系统管理员权限，以及指定目录的读写权限。
    
  
  
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  M-Compatibility兼容模式下不支持DBE_STATS高级包接口，其导出语句元信息中的统计信息无法被导入到相同兼容模式的DATABASE中。
  表36dbe_stats_tools.py接口参数说明 
  | 参数             | 是否允许为空 | 描述                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
  |:---|:---|:---|
  | --mode/-m      | 否    | 取值范围：dump、restore、explain、explain_analyze。 - dump：导出。  - restore：导入。  - explain：导出语句元信息，不实际执行语句。  - explain_analyze：导出语句元信息，实际执行语句。   |
  | --database/-d | 否   | 导出或导入的目标数据库名字。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | --port/-p     | 否      | 数据库端口号。取值范围是\[1, 65535\]。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | --user/-U      | 是     | 用户名，如果不输入-U参数，则会获取当前用户名作为参数值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
  | --passwd/-W   | 是     | 用户密码。如果指定该选项，需要单独输入密码。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
  | --host/-H       | 是   | 导出或导入目标数据库节点的IP。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  | --set/-s        | 是     | 在语句元信息收集模式下，设置会话级别GUC参数。可指定多次，对应多个GUC参数设置。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
  | --command/-c | 否     | 在语句元信息收集模式下，指定SQL文本。要求是单条可执行EXPLAIN的SQL语句，且不能带有EXPLAIN关键字。explain_analyze模式下仅支持SELECT语句。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
  | --file/-f      | 否     | 在语句元信息收集模式下，指定存放SQL文本的文件路径。要求是单条可执行EXPLAIN的SQL语句，且不能带有EXPLAIN关键字。explain_analyze模式下仅支持SELECT语句。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
  | --output/-o     | 否     | 存放导出统计信息的目录。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
     
  ![](https://support.huaweicloud.com/centralized-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
  - 统计信息导出后，会在--output参数所指定的目录下生成gs_stats.meta（元数据文件）和gs_stats.csv（指定DATABASE用户表的统计信息文件）。
  
  - 语句元信息导出后，会在--output参数所指定目录下生成以下目录及文件：
    - query.sql：存放输入的SQL语句文本。
    
    - metainfo_nohint：该目录默认生成，存放内容是语句无hint生效（当语句本身无hint或工具使其失效）时的信息：
      - explain.log：对SQL语句进行EXPLAIN的结果。
      
      - plantrace.log：计划生成的PLAN TRACE信息。
       
    
    - metainfo_hinted：仅当语句有hint生效时生成该目录，内容结构与metainfo_nohint一致。
    
    - objdefs.sql：所在DATABASE中所有对象的定义。
    
    - querytuning.conf：与计划调优相关的所有GUC参数配置，不包含应用的会话级别配置。
    
    - currstats：SQL语句所引用表对象的当前统计信息，目录结构与dump模式的输出一致。
    
    - histstats：SQL语句所引用表对象的历史统计信息，该目录下每一个histstats_\<timestamp\>子目录对应某个时间戳的统计信息快照，子目录下的文件结构与dump模式的输出一致。histstats下最多拥有50个历史统计信息快照，如果DATABASE中实际查询的快照总数超出该数目，输出的50个历史统计信息快照则为等距采样的结果。M-Compatibility兼容模式下无该内容。
     
   
  示例一：导出导入统计信息流程。
  ```
  # 导出统计信息流程示例。
  [omm@localhost ~]$ python3 dbe_stats_tools.py -m dump -d db1 -p 8000 --output ./stats
  export table name: "export_table_1749783328"
  execute: "gsql -d db1 -p 8000 -U omm -c "select 1 from pg_catalog.pg_class where relname = 'export_table_1749783328' and relnamespace = 2200;""
  execute: "gsql -d db1 -p 8000 -U omm -c "START TRANSACTION;call dbe_stats.create_stat_table(ownname => 'public', stattab => 'export_table_1749783328');call dbe_stats.export_database_stats(stattab=>'export_table_1749783328',statown=>'public');\COPY public.export_table_1749783328TO '/home/omm/stats/gs_stats.csv' WITH (FORMAT CSV, HEADER);call dbe_stats.drop_stat_table(ownname => 'public', stattab => 'export_table_1749783328');COMMIT;""
  execute: "gsql -d db1 -p 8000 -U omm -c "select pg_catalog.gs_get_current_version() from dual;""
  deployment: "P"
  dump complete!
  # 导出统计信息后，stats目录下会生成元数据文件和统计信息的dump文件。
  [omm@localhost ~]$ ls stats/
  gs_stats.csv  gs_stats.meta
  # 导入统计信息流程示例。
  [omm@localhost ~]$ python3 dbe_stats_tools.py -m restore -d db1 -p 8000 --output ./stats
  export table name: "export_table_1749783436"
  gs_stats meta file: "/home/omm/stats/gs_stats.meta"
  deployment: "P"
  execute: "gsql -d db1 -p 8000 -U omm -c "select pg_catalog.gs_get_current_version() from dual;""
  execute: "gsql -d db1 -p 8000 -U omm -c "select 1 from pg_catalog.pg_class where relname = 'export_table_1749783436' and relnamespace = 2200;""
  execute: "gsql -d db1 -p 8000 -U omm -c "START TRANSACTION;call dbe_stats.create_stat_table(ownname => 'public', stattab => 'export_table_1749783436');\COPY public.export_table_1749783436 FROM '/home/omm/stats/gs_stats.csv' WITH (FORMAT CSV, HEADER);call dbe_stats.import_database_stats(stattab=>'export_table_1749783436',statown=>'public');call dbe_stats.drop_stat_table(ownname => 'public', stattab => 'export_table_1749783436');COMMIT;""
  restore complete!
  ```
  示例二：通过语句元信息复现SQL计划不优问题。本示例包含了一个经典的计划不优问题：在数据变更后，未及时收集统计信息，导致选错索引的计划。
  前置操作：建表、插入数据、复现慢SQL业务。
  ```
  # 示例中使用的db1为A-Compatibility兼容模式数据库，请根据实际需要替换数据库名字。
  # 示例中执行命令的节点为数据库节点。
  [omm@localhost ~]$ gsql -d db1 -p 8000 -r
  -- 1.为避免基数反馈、计划复用等对该慢SQL问题复现产生影响，设置以下GUC参数。
  db1=# SET enable_feedback_cardest = OFF;
  SET
  db1=# SET cursor_sharing = OFF;
  SET
  db1=# SET explain_perf_mode = 'pretty';
  SET
  -- 2.预置数据，s表仅用于数据生成，t表是最终查询的业务表。
  db1=# DROP TABLE IF EXISTS s;
  NOTICE:  table "s" does not exist, skipping
  DROP TABLE
  db1=# CREATE TABLE s (
      i INT
  );
  CREATE TABLE
  db1=# INSERT INTO s SELECT generate_series(1, 550000);
  INSERT 0 550000
  db1=# ANALYZE s;
  ANALYZE
  db1=# DROP TABLE IF EXISTS t;
  NOTICE:  table "t" does not exist, skipping
  DROP TABLE
  db1=# CREATE TABLE t (
      idate INT,
      no    INT
  ) PARTITION BY RANGE (idate) (
      PARTITION p1 VALUES LESS THAN (200),
      PARTITION p2 VALUES LESS THAN (400),
      PARTITION p3 VALUES LESS THAN (MAXVALUE)
  );
  CREATE TABLE
  db1=# CREATE INDEX t_i  ON t(idate) LOCAL;
  CREATE INDEX
  db1=# CREATE INDEX t_no ON t(no)    LOCAL;
  CREATE INDEX
  db1=# INSERT INTO t
  SELECT floor(random() * 540) AS idate,
         floor(random() * 30)  AS no
    FROM s
   WHERE i <= 540000;
  INSERT 0 540000
  db1=# ANALYZE t;
  ANALYZE
  -- 3.插入新数据，但是不重新执行ANALYZE。
  db1=# INSERT INTO t
  SELECT floor(540 + random() * 10) AS idate,
         floor(random() * 30)       AS no
    FROM s
   WHERE i <= 1000000;
  INSERT 0 550000
  -- 4.查询新增部分数据（默认计划 vs hint计划）。
  db1=# EXPLAIN ANALYZE
  SELECT *
    FROM t
   WHERE idate >= 540 AND idate < 550 AND no = 1;
   id |                 operation                 | A-time  | A-rows | E-rows | Peak Memory | A-width | E-width |   E-costs    
  ----+-------------------------------------------+---------+--------+--------+-------------+---------+---------+--------------
    1 | ->  Partitioned Index Scan using t_i on t | 402.412 |  18516 |      1 | 18KB        |         |       8 | 0.000..2.273
  (1 row)
                       Predicate Information (identified by plan id)                      
  ----------------------------------------------------------------------------------------
     1 --Partitioned Index Scan using t_i on t
           Index Cond: ((idate >= 540) AND (idate < 550)), (Expression Flatten Optimized)
           Filter: (no = 1), (Expression Flatten Optimized)
           Rows Removed by Filter: 531484
           Selected Partitions:  3
  (5 rows)
         ====== Query Summary =====       
  ----------------------------------------
   Datanode executor start time: 0.105 ms
   Datanode executor run time: 404.668 ms
   Datanode executor end time: 0.024 ms
   Planner runtime: 0.670 ms
   Query Id: 1946117988977917582
   Total runtime: 404.818 ms
  (6 rows)
  db1=# EXPLAIN ANALYZE
  SELECT /*+ indexscan(t t_no) */ *
    FROM t
   WHERE idate >= 540 AND idate < 550 AND no = 1;
   id |                 operation                  | A-time | A-rows | E-rows | Peak Memory | A-width | E-width |     E-costs     
  ----+--------------------------------------------+--------+--------+--------+-------------+---------+---------+-----------------
    1 | ->  Partitioned Index Scan using t_no on t | 21.989 |  18516 |      1 | 19KB        |         |       8 | 0.000..3537.964
  (1 row)
                     Predicate Information (identified by plan id)                    
  ------------------------------------------------------------------------------------
     1 --Partitioned Index Scan using t_no on t
           Index Cond: (no = 1), (Expression Flatten Optimized)
           Filter: ((idate >= 540) AND (idate < 550)), (Expression Flatten Optimized)
           Rows Removed by Filter: 4660
           Selected Partitions:  3
  (5 rows)
         ====== Query Summary =====       
  ----------------------------------------
   Datanode executor start time: 0.086 ms
   Datanode executor run time: 23.600 ms
   Datanode executor end time: 0.017 ms
   Planner runtime: 0.598 ms
   Query Id: 1946117988977941689
   Total runtime: 23.725 ms
  (6 rows)
  db1=# \q
  ```
  场景一：通过-c选项收集带HINT SQL语句的元信息，对比HINT生效与不生效情况下的计划信息。
  ```
  # 指定带hint的SQL文本，收集其元信息。
  [omm@localhost ~]$ rm -rf ./hint_metainfo
  [omm@localhost ~]$ python3 $GAUSSHOME/bin/dbe_stats_tools.py -m explain_analyze -d db1 -p 8000 -c 'SELECT /*+ indexscan(t t_no) */ * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;' -o ./hint_metainfo
  execute: "gsql -d db1 -p 8000 -U omm -q -f -
  START TRANSACTION READ ONLY;
  set explain_perf_mode = pretty; set cursor_sharing = off;
  explain (metadata on, tables on, plantrace on, analyze on) SELECT /*+ indexscan(t t_no) */ * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;
  ROLLBACK;"
  execute: "gsql -d db1 -p 8000 -U omm -q -f -
  START TRANSACTION READ ONLY;
  set explain_perf_mode = pretty; set cursor_sharing = off;
  set parser_ignore_hints = on;
  explain (metadata on, tables on, plantrace on, analyze on) SELECT /*+ indexscan(t t_no) */ * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;
  ROLLBACK;"
  explaining query completed!
  dumping query tuning settings completed!
  dumping object definition completed!
  dumping current statistics completed!
  dumping historical statistics completed!
  # 此时得到该语句在hint生效与不生效时的计划信息，以及其它可用于复现的信息。
  [omm@localhost ~]$ ls -R ./hint_metainfo/
  ./hint_metainfo/:
  currstats  histstats  metainfo_hinted  metainfo_nohint  objdefs.sql  query.sql  querytuning.conf
  ./hint_metainfo/currstats:
  gs_stats.csv  gs_stats.meta
  ./hint_metainfo/histstats:
  histstats_2026-07-21_17:03:22.428581+08
  ./hint_metainfo/histstats/histstats_2026-07-21_17:03:22.428581+08:
  gs_stats.csv  gs_stats.meta
  ./hint_metainfo/metainfo_hinted:
  explain.log  plantrace.log
  ./hint_metainfo/metainfo_nohint:
  explain.log  plantrace.log
  ```
  场景二：通过-f选项收集对应语句的元信息，并尝试在测试库中复现当前与历史执行计划。
  ```
  # 通过gsql连接，对t表执行ANALYZE，更新其统计信息。
  [omm@localhost ~]$ gsql -d db1 -p 8000 -r
  db1=# SET enable_feedback_cardest = OFF;
  SET
  db1=# SET cursor_sharing = OFF;
  SET
  db1=# SET explain_perf_mode = 'pretty';
  SET
  -- 执行ANALYZE解决慢SQL问题。
  db1=# ANALYZE t;
  ANALYZE
  -- 5.重新收集统计信息后，计划默认最优。
  db1=# EXPLAIN ANALYZE
  SELECT *
    FROM t
   WHERE idate >= 540 AND idate < 550 AND no = 1;
   id |                    operation                    | A-time | A-rows | E-rows | Peak Memory | A-width | E-width |      E-costs      
  ----+-------------------------------------------------+--------+--------+--------+-------------+---------+---------+-------------------
    1 | ->  Partitioned Bitmap Heap Scan on t           | 23.039 |  18224 |  18805 | 44KB        |         |       8 | 359.296..5159.694
    2 |    ->  Partitioned Bitmap Index Scan using t_no | 4.209  |  22878 |  37337 | 310KB       |         |       0 | 0.000..354.595
  (2 rows)
                     Predicate Information (identified by plan id)                    
  ------------------------------------------------------------------------------------
     1 --Partitioned Bitmap Heap Scan on t
           Recheck Cond: (no = 1), (Expression Flatten Optimized)
           Filter: ((idate >= 540) AND (idate < 550)), (Expression Flatten Optimized)
           Rows Removed by Filter: 4654
           Heap Blocks: exact=2625
           Selected Partitions:  3
     2 --Partitioned Bitmap Index Scan using t_no
           Index Cond: (no = 1)
  (8 rows)
         ====== Query Summary =====       
  ----------------------------------------
   Datanode executor start time: 0.107 ms
   Datanode executor run time: 24.616 ms
   Datanode executor end time: 0.032 ms
   Planner runtime: 0.589 ms
   Query Id: 1946117988978261850
   Total runtime: 24.766 ms
  (6 rows)
  db1=# \q
  # 通过指定SQL文本文件的方式，收集语句元信息。
  [omm@localhost ~]$ echo 'SELECT * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;' > ./tmp.sql
  [omm@localhost ~]$ python3 $GAUSSHOME/bin/dbe_stats_tools.py -m explain_analyze -d db1 -p 8000 -f ./tmp.sql -o ./hist_metainfo
  execute: "gsql -d db1 -p 8000 -U omm -q -f -
  START TRANSACTION READ ONLY;
  set explain_perf_mode = pretty; set cursor_sharing = off;
  explain (metadata on, tables on, plantrace on, analyze on) SELECT * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;
  ROLLBACK;"
  explaining query completed!
  dumping query tuning settings completed!
  dumping object definition completed!
  dumping current statistics completed!
  dumping historical statistics completed!
  # 此时导出的语句元信息有多个历史统计信息快照。
  [omm@localhost ~]$ ls -R ./hist_metainfo
  ./hist_metainfo:
  currstats  histstats  metainfo_nohint  objdefs.sql  query.sql  querytuning.conf
  ./hist_metainfo/currstats:
  gs_stats.csv  gs_stats.meta
  ./hist_metainfo/histstats:
  histstats_2026-07-21_17:03:22.428581+08  histstats_2026-07-21_17:05:39.673755+08
  ./hist_metainfo/histstats/histstats_2026-07-21_17:03:22.428581+08:
  gs_stats.csv  gs_stats.meta
  ./hist_metainfo/histstats/histstats_2026-07-21_17:05:39.673755+08:
  gs_stats.csv  gs_stats.meta
  ./hist_metainfo/metainfo_nohint:
  explain.log  plantrace.log
  # 创建一个测试库，导入对象定义与统计信息。
  [omm@localhost ~]$ gsql -d postgres -p 8000 -c 'DROP DATABASE IF EXISTS db_test;'
  NOTICE:  database "db_test" does not exist, skipping
  DROP DATABASE
  [omm@localhost ~]$ gsql -d postgres -p 8000 -c "CREATE DATABASE db_test WITH dbcompatibility = 'A';"
  CREATE DATABASE
  [omm@localhost ~]$ gsql -d db_test -p 8000 -q -f ./hist_metainfo/objdefs.sql 
  gsql:./hist_metainfo/objdefs.sql:13: WARNING:  Extension is not a secure feature, and it may cause unexpected errors.
  total time: 104  ms
  # 先尝试导入当前统计信息，复现修复后的执行计划。
  [omm@localhost ~]$ python3 $GAUSSHOME/bin/dbe_stats_tools.py -m restore -d db_test -p 8000 --output ./hist_metainfo/currstats
  export table name: "export_table_1784624958"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  select pg_catalog.gs_get_current_version() from dual;"
  gs_stats meta file: "/home/omm/hist_metainfo/currstats/gs_stats.meta"
  deployment: "P"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  select 1 from pg_catalog.pg_class where relname = 'export_table_1784624958' and relnamespace = 2200;"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  START TRANSACTION;call dbe_stats.create_stat_table(ownname => 'public', stattab => 'export_table_1784624958');\COPY public.export_table_1784624958 FROM '/home/omm/hist_metainfo/currstats/gs_stats.csv' WITH (FORMAT CSV, HEADER);call dbe_stats.import_database_stats(stattab=>'export_table_1784624958',statown=>'public');call dbe_stats.drop_stat_table(ownname => 'public', stattab => 'export_table_1784624958');COMMIT;"
  restore complete!
  [omm@localhost ~]$ gsql -d db_test -p 8000 -c "SET cursor_sharing = OFF; SET enable_feedback_cardest = OFF; SET explain_perf_mode = 'pretty'; EXPLAIN SELECT * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;"
  SET
  SET
  SET
   id |                    operation                    | E-rows | E-width |      E-costs      
  ----+-------------------------------------------------+--------+---------+-------------------
    1 | ->  Partitioned Bitmap Heap Scan on t           |  18805 |       8 | 376.970..5177.368
    2 |    ->  Partitioned Bitmap Index Scan using t_no |  37337 |       0 | 0.000..372.269
  (2 rows)
                     Predicate Information (identified by plan id)                    
  ------------------------------------------------------------------------------------
     1 --Partitioned Bitmap Heap Scan on t
           Recheck Cond: (no = 1), (Expression Flatten Optimized)
           Filter: ((idate >= 540) AND (idate < 550)), (Expression Flatten Optimized)
           Selected Partitions:  3
     2 --Partitioned Bitmap Index Scan using t_no
           Index Cond: (no = 1)
  (6 rows)
  # 再尝试导入历史统计信息，复现修复前的执行计划（选择最接近问题发生时的时间戳）。
  [omm@localhost ~]$ python3 $GAUSSHOME/bin/dbe_stats_tools.py -m restore -d db_test -p 8000 --output ./hist_metainfo/histstats/histstats_2026-07-21_17\:03\:22.428581+08
  export table name: "export_table_1784625703"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  select pg_catalog.gs_get_current_version() from dual;"
  gs_stats meta file: "/home/omm/hist_metainfo/histstats/histstats_2026-07-21_17:03:22.428581+08/gs_stats.meta"
  deployment: "P"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  select 1 from pg_catalog.pg_class where relname = 'export_table_1784625703' and relnamespace = 2200;"
  execute: "gsql -d db_test -p 8000 -U omm -q -f -
  START TRANSACTION;call dbe_stats.create_stat_table(ownname => 'public', stattab => 'export_table_1784625703');\COPY public.export_table_1784625703 FROM '/home/omm/hist_metainfo/histstats/histstats_2026-07-21_17:03:22.428581+08/gs_stats.csv' WITH (FORMAT CSV, HEADER);call dbe_stats.import_database_stats(stattab=>'export_table_1784625703',statown=>'public');call dbe_stats.drop_stat_table(ownname => 'public', stattab => 'export_table_1784625703');COMMIT;"
  restore complete!
  [omm@localhost ~]$ gsql -d db_test -p 8000 -c 'SET cursor_sharing = OFF; SET enable_feedback_cardest = OFF; SET explain_perf_mode = 'pretty'; EXPLAIN SELECT * FROM t WHERE idate >= 540 AND idate < 550 AND no = 1;'
  SET
  SET
  SET
   id |                 operation                 | E-rows | E-width |   E-costs    
  ----+-------------------------------------------+--------+---------+--------------
    1 | ->  Partitioned Index Scan using t_i on t |      1 |       8 | 0.000..2.273
  (1 row)
                       Predicate Information (identified by plan id)                      
  ----------------------------------------------------------------------------------------
     1 --Partitioned Index Scan using t_i on t
           Index Cond: ((idate >= 540) AND (idate < 550)), (Expression Flatten Optimized)
           Filter: (no = 1), (Expression Flatten Optimized)
           Selected Partitions:  3
  (4 rows)
  ```
  后置操作：清理数据库对象与导出目录文件。
  ```
  # 清理数据库对象。
  [omm@localhost ~]$ gsql -d db1 -p 8000 -r
  db1=# DROP TABLE s CASCADE;
  DROP TABLE
  db1=# DROP TABLE t CASCADE;
  DROP TABLE
  db1=# DROP DATABASE db_test;
  DROP DATABASE
  db1=# \q
  # 清理导出文件。
  [omm@localhost ~]$ rm -rf ./hint_metainfo
  [omm@localhost ~]$ rm -rf ./hist_metainfo
  ```
  
 
