openGauss Backup and Recovery

Stone大约 115 分钟

openGauss Backup and Recovery

应该定期对生产数据库进行备份，以便在出现诸如系统崩溃，硬件故障或者用户误删数据时恢复数据库。

概述

数据备份是保护数据安全的重要手段之一，为了更好的保护数据安全，openGauss 数据库支持三种备份恢复类型，以及多种备份恢复方案，备份和恢复过程中提供数据的可靠性保障机制。

备份与恢复类型可分为逻辑备份与恢复、物理备份与恢复、闪回恢复。

逻辑备份与恢复：通过逻辑导出对数据进行备份，逻辑备份只能基于备份时刻进行数据转储，所以恢复时也只能恢复到备份时保存的数据。对于故障点和备份点之间的数据，逻辑备份无能为力，逻辑备份适合备份那些很少变化的数据，当这些数据因误操作被损坏时，可以通过逻辑备份进行快速恢复。如果通过逻辑备份进行全库恢复，通常需要重建数据库，导入备份数据来完成，对于可用性要求很高的数据库，这种恢复时间太长，通常不被采用。由于逻辑备份具有平台无关性，所以更为常见的是，逻辑备份被作为一个数据迁移及移动的主要手段。
物理备份与恢复：通过物理文件拷贝的方式对数据库进行备份，以磁盘块为基本单位将数据从主机复制到备机。通过备份的数据文件及归档日志等文件，数据库可以进行完全恢复。物理备份速度快，一般被用作对数据进行备份和恢复，用于全量备份的场景。通过合理规划，可以低成本进行备份与恢复。
闪回恢复：利用回收站的闪回恢复删除的表。数据库的回收站功能类似于 Windows 系统的回收站，将删除的表信息保存到回收站中。利用 MVCC 机制闪回恢复到指定时间点或者 CSN 点。

三种备份恢复类型对比：

备份类型	工具名称	恢复时间	优缺点
逻辑备份与恢复	gs_dump	纯文本格式数据恢复时间长。归档格式数据恢复时间中等。	导出数据库相关信息的工具，用户可以自定义导出一个数据库或其中的对象（模式、表、视图等）。支持导出的数据库可以是默认数据库 `postgres`，也可以是自定义数据库。导出的格式可选择纯文本格式或者归档格式。纯文本格式的数据只能通过 `gsql` 进行恢复，恢复时间较长。归档格式的数据只能通过 `gs_restore` 进行恢复，恢复时间较纯文本格式短。
逻辑备份与恢复	gs_dumpall	数据恢复时间长。	导出所有数据库相关信息工具，它可以导出 openGauss 数据库的所有数据，包括默认数据库 `postgres` 的数据、自定义数据库的数据、以及 openGauss 所有数据库公共的全局对象。只能导出纯文本格式的数据，导出的数据只能通过 `gsql` 进行恢复，恢复时间较长。
物理备份与恢复	gs_backup	数据量小数据恢复时间快。	导出数据库相关信息的 OM 工具，可以导出数据库参数文件和二进制文件。帮助 openGauss 备份、恢复重要数据、显示帮助信息和版本号信息。在进行备份时，可以选择备份内容的类型，在进行还原时，需要保证各节点备份目录中存在备份文件。在数据库实例恢复时，通过静态配置文件中的数据库实例信息进行恢复。只恢复参数文件恢复时间较短。
物理备份与恢复	gs_basebackup	恢复时可以直接拷贝替换原有的文件，或者直接在备份的库上启动数据库，恢复时间快。	对服务器数据库文件的二进制进行全量拷贝，只能对数据库某一个时间点作全量备份。结合 PITR 恢复，可恢复全量备份时间点后的某一时间点。
物理备份与恢复	gs_probackup	恢复时可以直接恢复到某个备份点，在备份的库上启动数据库，恢复时间快。	`gs_probackup` 是一个用于管理 openGauss 数据库备份和恢复的工具。它对 openGauss 实例进行定期备份。可用于备份单机数据库或者数据库实例主节点，为物理备份。可备份外部目录的内容，如脚本文件、配置文件、日志文件、DUMP 文件等。支持增量备份、定期备份和远程备份。增量备份时间相对于全量备份时间比较短，只需要备份修改的文件。当前默认备份是数据目录，如果表空间不在数据目录，需要手动指定备份的表空间目录进行备份。当前只支持在主机上执行备份。
闪回恢复	无	可以将表的状态恢复到指定时间点或者是表结构删除前的状态，恢复时间快。	闪回技术能够有选择性的高效撤销一个已提交事务的影响，从人为错误中恢复。在采用闪回技术之前，只能通过备份恢复、PITR 等手段找回已提交的数据库修改，恢复时长需要数分钟甚至数小时。采用闪回技术后，恢复已提交的数据库修改前的数据，只需要秒级，而且恢复时间和数据库大小无关。闪回支持两种恢复模式： 1. 基于 MVCC 多版本的数据恢复：适用于误删除、误更新、误插入数据的查询和恢复，用户通过配置旧版本保留时间，并执行相应的查询或恢复命令，查询或恢复到指定的时间点或 CSN 点。 2. 基于类似 Windows 系统回收站的恢复：适用于误 DROP、误 TRUNCATE 的表的恢复。用户通过配置回收站开关，并执行相应的恢复命令，可以将误 DROP、误 TRUNCATE 的表找回。

当需要进行备份恢复操作时，主要从以下四个方面考虑数据备份方案。

备份对业务的影响在可接受范围。
数据库恢复效率。为尽量减小数据库故障的影响，要使恢复时间减到最少，从而使恢复的效率达到最高。
数据可恢复程度。当数据库失效后，要尽量减少数据损失。
数据库恢复成本。

配置文件的备份与恢复

在 openGauss 使用过程中，如果静态配置文件无意损坏后，会影响 openGauss 感知 openGauss 拓扑结构和主备关系。使用 gs_om 工具生成的静态配置文件，可以替换已经损坏的配置文件，保证 openGauss 的正常运行。

重新生成静态配置文件：

[root@opengauss ~]# su - omm 
[omm@opengauss ~]$ gs_om -t generateconf -X /opt/software/openGauss/cluster_config.xml --distribute
Generating static configuration files for all nodes.
Creating temp directory to store static configuration files.
Successfully created the temp directory.
Generating static configuration files.
Successfully generated static configuration files.
Static configuration files for all nodes are saved in /opt/huawei/install/om/script/static_config_files.
Distributing static configuration files to all nodes.
Successfully distributed static configuration files.
[omm@opengauss ~]$ ll /opt/huawei/install/om/script/static_config_files
total 36
-rwxr-x--- 1 omm dbgrp 40960 Mar 28 13:29 cluster_static_config_opengauss

逻辑备份与恢复

gs_dump

gs_dump 是 openGauss 用于导出数据库相关信息的工具，用户可以自定义导出一个数据库或其中的对象（模式、表、视图等），回收站对象除外。支持导出的数据库可以是默认数据库 postgres，也可以是自定义数据库。

gs_dump 工具由操作系统用户 omm 执行。
gs_dump 工具在进行数据导出时，其他用户可以访问 openGauss 数据库（读或写）。
gs_dump 工具支持导出完整一致的数据。例如，T1 时刻启动 gs_dump 导出 A 数据库，那么导出数据结果将会是 T1 时刻 A 数据库的数据状态，T1 时刻之后对 A 数据库的修改不会被导出。
gs_dump 时生成列不会被转储。
gs_dump 支持导出兼容 V1 版本数据库的文本格式文件。
gs_dump 支持将数据库信息导出至纯文本格式的 SQL 脚本文件或其他归档文件中。
- 纯文本格式的 SQL 脚本文件：包含将数据库恢复为其保存时的状态所需的SQL语句。通过 gsql 运行该 SQL 脚本文件，可以恢复数据库。即使在其他主机和其他数据库产品上，只要对 SQL 脚本文件稍作修改，也可以用来重建数据库。
- 归档格式文件：包含将数据库恢复为其保存时的状态所需的数据，可以是 TAR 格式、目录归档格式或自定义归档格式。该导出结果必须与 gs_restore 配合使用来恢复数据库，gs_restore 工具在导入时，系统允许用户选择需要导入的内容，甚至可以在导入之前对等待导入的内容进行排序。
gs_dump 工具支持使用过程中打印进度。首先在对数据库的全局扫描阶段会打印扫描流程进行到具体哪一步。在转存数据阶段会根据已经完成的对象数比上总对象数打印进度。

gs_dump 可以通过 -F 或者 --format= 选项指定四种不同的导出文件格式：

格式名称	-F的参数值	说明	建议	对应导入工具
纯文本格式	p	纯文本脚本文件包含 SQL 语句和命令。命令可以由 `gsql` 命令行终端程序执行，用于重新创建数据库对象并加载表数据。	小型数据库，一般推荐纯文本格式。	使用 `gsql` 工具恢复数据库对象前，可根据需要使用文本编辑器编辑纯文本导出文件。
自定义归档格式	c	一种二进制文件。支持从导出文件中恢复所有或所选数据库对象。	中型或大型数据库，推荐自定义归档格式。	使用 `gs_restore` 从自定义归档文件中导入相应的数据库对象。
目录归档格式	d	该格式会创建一个目录，该目录包含两类文件，一类是目录文件，另一类是每个表和 BLOB 对象对应的数据文件。		使用 `gs_restore` 从目录归档文件中导入相应的数据库对象。
TAR 归档格式	t	TAR 归档文件支持从导出文件中恢复所有或所选数据库对象。TAR 归档格式不支持压缩且对于单独表大小应小于 8GB。		使用 `gs_restore` 从 TAR 归档文件中导入相应的数据库对象。

可以使用 gs_dump 程序将文件压缩为目录归档或自定义归档导出文件，减少导出文件的大小。生成目录归档或自定义归档导出文件时，默认进行中等级别的压缩。gs_dump 程序无法压缩已归档导出文件。
禁止修改 c/d/t 格式导出的文件和内容，否则可能无法恢复成功。对于 p 格式导出的文件，如有需要，可根据需要谨慎编辑导出文件。
为了保证数据一致性和完整性，gs_dump 会对需要转储的表设置共享锁。如果表在别的事务中设置了共享锁，gs_dump 会等待锁释放后锁定表。如果无法在指定时间内锁定某个表，转储会失败。用户可以通过指定 --lock-wait-timeout 选项，自定义等待锁超时时间。
不支持加密导出存储过程和函数。

语法：

gs_dump [OPTION]... [DBNAME]

通用参数：

-f, --file=FILENAME：将输出发送至指定文件或目录。如果省略该参数，则使用标准输出。如果输出格式为 -F c/-F d/-F t 时，必须指定 -f 参数。如果 -f 的参数值含有目录，要求当前用户对该目录具有读写权限，并且不能指定已有目录。
-F, --format=c|d|t|p：选择输出格式。格式如下：
- p|plain：输出一个文本 SQL 脚本文件（默认）。
- c|custom：输出一个自定义格式的归档，并且以目录形式输出，作为 gs_restore 输入信息。该格式是最灵活的输出格式，因为能手动选择，而且能在恢复过程中将归档项重新排序。该格式默认状态下会被压缩。
- d|directory：该格式会创建一个目录，该目录包含两类文件，一类是目录文件，另一类是每个表和 BLOB 对象对应的数据文件。
- t|tar：输出一个 TAR 格式的归档形式，作为 gs_restore 输入信息。TAR 格式与目录格式兼容；TAR 格式归档形式在提取过程中会生成一个有效的目录格式归档形式。但是，TAR 格式不支持压缩且对于单独表有 8GB 的大小限制。此外，表数据项的相应排序在恢复过程中不能更改。
-v, --verbose：指定 Verbose 模式。该选项将导致 gs_dump 向转储文件输出详细的对象注解和启动/停止次数，向标准错误流输出处理信息。
-Z, --compress=0-9：指定使用的压缩比级别。取值范围：0~9，0表示无压缩。1表示压缩比最小，处理速度最快。9表示压缩比最大，处理速度最慢。针对自定义归档格式，该选项指定单个表数据片段的压缩，默认方式是以中等级别进行压缩。TAR 归档格式和纯文本格式目前不支持压缩。
--lock-wait-timeout=TIMEOUT：如果无法在指定时间内锁定某个表，就选择失败。可以以任何符合 SET statement_timeout 的格式指定超时时间。

导出参数：

-a, --data-only：只导出数据，不导出对象定义。导出表数据、大对象和序列值。
-s, --schema-only：只导出对象定义，不导出数据。
-c, --clean：在将创建数据库对象的指令输出到备份文件之前，先将清理（删除）数据库对象的指令输出到备份文件中。（如果目标数据库中没有任何对象，gs_restore 工具可能会输出一些提示性的错误信息）。该选项只对文本格式有意义。针对归档格式，可以调用 gs_restore 时指定选项。
-C, --create：备份文件以创建数据库和连接到创建的数据库的命令开始。（如果命令脚本是这种方式执行，可以先指定任意数据库用于执行创建数据库的命令，数据不会恢复到指定的数据库中，而是恢复到创建的数据库中。）该选项只对文本格式有意义。针对归档格式，可以在调用 gs_restore 时指定选项。
-E, --encoding=ENCODING：以指定的字符集编码创建转储。默认情况下，以数据库编码创建转储。（得到相同结果的另一个办法是将环境变量 PGCLIENTENCODING 设置为所需的转储编码。）
-g, --exclude-guc=GUC_PARAM ：不转储 GUC_PARAM 设置。
-n, --schema=SCHEMA：只转储与模式名称匹配的模式，此选项包括模式本身和所有它包含的对象。如果该选项没有指定，所有在目标数据库中的非系统模式将会被转储。写入多个 -n 选项来选择多个模式。多个模式也可以写入通配符来选择。使用通配符时，注意打引号，防止 Shell 扩展通配符。
-N, --exclude-schema=SCHEMA：不转储与模式名称匹配的模式。写入多个 -N 选项来选择多个模式。
-O, --no-owner：不输出设置对象的归属这样的命令，以匹配原始数据库。默认情况下，gs_dump 会发出 ALTER OWNER 或 SET SESSION AUTHORIZATION 语句设置所创建的数据库对象的归属。通过指定 -O，编写一个任何用户都能存储的脚本，且该脚本会授予该用户拥有所有对象的权限。该选项只对文本格式有意义。针对归档格式，可以在调用 gs_restore 时指定选项。
-q, --target=VERSION：指定兼容的数据库版本。
-t, --table=TABLE：指定转储的表（或视图、或序列、或外表）对象列表，可以使用多个-t选项来选择多个表，也可以使用通配符指定多个表对象。当使用通配符指定多个表对象时，注意打引号，防止 Shell 扩展通配符。
- -t 参数选项个数必须小于等于 100。
- 如果 -t 参数选项个数大于 100，建议使用参数 --include-table-file 来替换。
- 当 -t 已指定时，gs_dump 不会转储已选表所附着的任何其他数据库对象。因此，无法保证某个指定表的转储结果能够自行成功地储存到一个空数据库中。
- -t tablename 只转储在默认搜索路径中可见的表。-t *.tablename 转储数据库下所有模式下的指定表。-t schema.table 转储特定模式中的表。
- -t tablename 不会导出表上的触发器信息。
- 对于表名中包含大写字母的表，在使用 -t 参数指定导出时需对表名添加 "" 来导出。如对于表 "abC”，导出需指定 -t "abC"；如对于表 schema.“abC”，导出需指定 -t schema."abC"。
--include-table-file=FileName：指定包含要转储的表名称的文件。一行一个表名称，格式为：schema.table。
-T, --exclude-table=TABLE：不转储的表（或视图、或序列、或外表）对象列表，可以使用多个 -T 选项来选择多个表，也可以使用通配符指定多个表对象。
--exclude-table-file=FileName：指定包含不要转储的表名称的文件。一行一个表名称，格式为：schema.table。
--pipeline：使用管道传输密码，禁止在终端使用。
-x, --no-privileges/--no-acl：防止转储访问权限。
--column-inserts/--attribute-inserts：以 INSERT 命令带列名方式导出数据。这会导致恢复缓慢。但是由于该选项会针对每行生成一个独立分开的命令，所以在重新加载某行时出现的错误只会导致那行丢失，而非整个表内容。
--disable-dollar-quoting：禁止在函数体前使用美元符号 $，并强制使用 SQL 标准字符串语法对其进行引用。
--exclude-table-data=TABLE：不转储指定表的数据。
--inserts：发出 INSERT 命令（而非 COPY 命令）转储数据。这会导致恢复缓慢。但是由于该选项会针对每行生成一个独立分开的命令，所以在重新加载某行时出现的错误只会导致那行丢失，而非整个表内容。注意：如果重排列顺序，可能会导致整个恢复失败。列顺序改变时，--column-inserts 选项不受影响，虽然会更慢。
--no-tablespaces：不输出选择表空间的命令。使用该选项，无论默认表空间是哪个，在恢复过程中所有对象都会被创建。该选项只对文本格式有意义。针对归档格式，可以在调用 gs_restore 时指定选项。
--include-depend-objs：备份结果包含依赖于指定对象的对象信息。该参数需要同 -t/--include-table-file 参数关联使用才会生效。
--exclude-self：备份结果不包含指定对象自身的信息。该参数需要同 -t/--include-table-file 参数关联使用才会生效。

连接参数：

-h, --host=HOSTNAME：指定主机名称，缺省从 PGHOST 环境变量中获取。
-p, --port=PORT：指定主机端口，缺省从 PGPORT 环境变量中获取。
-U, --username=NAME：指定所连接主机的用户名，缺省从 PGUSER 环境变量中获取。
-w, --no-password：不出现输入密码提示。如果主机要求密码认证并且密码没有通过其它形式给出，则连接尝试将会失败。该选项在批量工作和不存在用户输入密码的脚本中很有帮助。
-W, --password=PASSWORD：指定用户连接的密码。
--role=ROLENAME：指定创建转储使用的角色名。选择该选项，会使 gs_dump 连接数据库后，发起一个 SET ROLE 角色名命令。当所授权用户（由 -U 指定）没有 gs_dump 要求的权限时，该选项会起到作用，即切换到具备相应权限的角色。某些安装操作规定不允许直接以超系统管理员身份登录，而使用该选项能够在不违反该规定的情况下完成转储。
--rolepassword=ROLEPASSWORD：指定角色名的密码。

注意：

如果 openGauss 有任何本地数据要添加到 template1 数据库，请谨慎将 gs_dump 的输出恢复到一个真正的空数据库中，否则可能会因为被添加对象的定义被复制，出现错误。要创建一个无本地添加的空数据库，需从 template0 而非 template1 复制。
TAR 归档形式的文件大小不得超过 8GB（TAR 文件格式的固有限制）。TAR 文档整体大小和任何其他输出格式没有限制，操作系统可能对此有要求。
由 gs_dump 生成的转储文件不包含优化程序用来做执行计划决定的统计数据。因此，最好从某转储文件恢复之后运行 ANALYZE 以确保最佳效果。转储文件不包含任何 ALTER DATABASE…SET 命令，这些设置由 gs_dumpall 转储，还有数据库用户和其他完成安装设置。

例子：导出 postgres 数据库中的 stone 模式的所有数据，以 SQL 文件格式保存到指定文件

[omm@opengauss ~]$ gs_dump -n stone -f backup/stone_backup.sql postgres
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: Finish scanning database. 
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: Start dumping objects 
Progress: [==================================================] 100% (4887/4887, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: Finish dumping objects 
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: dump database postgres successfully
gs_dump[port='15400'][postgres][2025-03-31 15:41:39]: total time: 394  ms

导出的数据如下：

[omm@opengauss ~]$ cat backup/stone_backup.sql 
--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'SQL_ASCII';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: postgres; Type: COMMENT; Schema: -; Owner: omm
--

COMMENT ON DATABASE postgres IS 'default administrative connection database';


--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


--
-- Name: stone; Type: SCHEMA; Schema: -; Owner: stone
--

CREATE SCHEMA stone;


ALTER SCHEMA stone OWNER TO stone;

SET search_path = stone;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: staff; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE staff (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.staff OWNER TO stone;

--
-- Name: staff1; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE staff1 (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer NOT NULL,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.staff1 OWNER TO stone;

--
-- Name: staff4; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE staff4 (
    id integer NOT NULL,
    name text NOT NULL,
    age integer NOT NULL,
    address character(50),
    salary real,
    CONSTRAINT staff4_salary_check CHECK ((salary > (0)::double precision))
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.staff4 OWNER TO stone;

--
-- Name: type_t1; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE type_t1 (
    a tinyint,
    b integer,
    c bigint,
    d numeric(10,4)
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.type_t1 OWNER TO stone;

--
-- Name: type_t2; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE type_t2 (
    a smallint NOT NULL,
    b integer NOT NULL,
    c bigint NOT NULL,
    d real,
    e numeric(10,4)
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.type_t2 OWNER TO stone;

--
-- Name: type_t2_a_seq; Type: SEQUENCE; Schema: stone; Owner: stone
--

CREATE  SEQUENCE type_t2_a_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE stone.type_t2_a_seq OWNER TO stone;

--
-- Name: type_t2_a_seq; Type: LARGE SEQUENCE OWNED BY; Schema: stone; Owner: stone
--

ALTER  SEQUENCE type_t2_a_seq OWNED BY type_t2.a;


--
-- Name: type_t2_b_seq; Type: SEQUENCE; Schema: stone; Owner: stone
--

CREATE  SEQUENCE type_t2_b_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE stone.type_t2_b_seq OWNER TO stone;

--
-- Name: type_t2_b_seq; Type: LARGE SEQUENCE OWNED BY; Schema: stone; Owner: stone
--

ALTER  SEQUENCE type_t2_b_seq OWNED BY type_t2.b;


--
-- Name: type_t2_c_seq; Type: SEQUENCE; Schema: stone; Owner: stone
--

CREATE  SEQUENCE type_t2_c_seq
    START WITH 1
    INCREMENT BY 1
    NO MINVALUE
    NO MAXVALUE
    CACHE 1;


ALTER SEQUENCE stone.type_t2_c_seq OWNER TO stone;

--
-- Name: type_t2_c_seq; Type: LARGE SEQUENCE OWNED BY; Schema: stone; Owner: stone
--

ALTER  SEQUENCE type_t2_c_seq OWNED BY type_t2.c;


--
-- Name: type_t3; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE type_t3 (
    a character(4),
    b character varying(5)
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.type_t3 OWNER TO stone;

--
-- Name: type_t4; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE type_t4 (
    a time without time zone,
    b time with time zone,
    c timestamp without time zone,
    d timestamp with time zone,
    e smalldatetime
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.type_t4 OWNER TO stone;

--
-- Name: type_t5; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE type_t5 (
    a boolean,
    b text
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.type_t5 OWNER TO stone;

--
-- Name: a; Type: DEFAULT; Schema: stone; Owner: stone
--

ALTER TABLE type_t2 ALTER COLUMN a SET DEFAULT nextval('type_t2_a_seq'::regclass);


--
-- Name: b; Type: DEFAULT; Schema: stone; Owner: stone
--

ALTER TABLE type_t2 ALTER COLUMN b SET DEFAULT nextval('type_t2_b_seq'::regclass);


--
-- Name: c; Type: DEFAULT; Schema: stone; Owner: stone
--

ALTER TABLE type_t2 ALTER COLUMN c SET DEFAULT nextval('type_t2_c_seq'::regclass);


--
-- Data for Name: staff; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.staff (id, name, age, address, salary) FROM stdin;
1       lily            28      \N      \N
\.
;

--
-- Data for Name: staff1; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.staff1 (id, name, age, address, salary) FROM stdin;
1       lily            28      \N      \N
\.
;

--
-- Data for Name: staff4; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.staff4 (id, name, age, address, salary) FROM stdin;
\.
;

--
-- Data for Name: type_t1; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.type_t1 (a, b, c, d) FROM stdin;
100     1000    10000   123456.1223
\.
;

--
-- Data for Name: type_t2; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.type_t2 (a, b, c, d, e) FROM stdin;
1       1       1       10.2654562      123.1237
2       2       2       10.2654562      123.1237
\.
;

--
-- Name: type_t2_a_seq; Type: SEQUENCE SET; Schema: stone; Owner: stone
--

SELECT pg_catalog.setval('type_t2_a_seq', 2, true);


--
-- Name: type_t2_b_seq; Type: SEQUENCE SET; Schema: stone; Owner: stone
--

SELECT pg_catalog.setval('type_t2_b_seq', 2, true);


--
-- Name: type_t2_c_seq; Type: SEQUENCE SET; Schema: stone; Owner: stone
--

SELECT pg_catalog.setval('type_t2_c_seq', 2, true);


--
-- Data for Name: type_t3; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.type_t3 (a, b) FROM stdin;
ok      good
\.
;

--
-- Data for Name: type_t4; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.type_t4 (a, b, c, d, e) FROM stdin;
21:21:21        21:21:21-08     2010-12-12 00:00:00     2013-12-11 16:00:00+08  2003-04-12 04:05:00
\.
;

--
-- Data for Name: type_t5; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.type_t5 (a, b) FROM stdin;
t       true
t       true
f       false
f       false
\.
;

--
-- Name: staff1_age_key; Type: CONSTRAINT; Schema: stone; Owner: stone; Tablespace: 
--

ALTER TABLE staff1
    ADD CONSTRAINT staff1_age_key UNIQUE (age);


--
-- Name: staff4_pkey; Type: CONSTRAINT; Schema: stone; Owner: stone; Tablespace: 
--

ALTER TABLE staff4
    ADD CONSTRAINT staff4_pkey PRIMARY KEY  (id);


--
-- openGauss database dump complete
--

例子：导出 postgres 数据库中的 stone 模式的所有数据，以 TAR 文件格式保存到指定文件

[omm@opengauss ~]$ gs_dump -n stone -F t -f backup/stone_backup.tar postgres
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: Finish scanning database. 
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: Start dumping objects 
Progress: [==================================================] 100% (4887/4887, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: Finish dumping objects 
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: dump database postgres successfully
gs_dump[port='15400'][postgres][2025-03-31 15:49:21]: total time: 320  ms

导出的 TAR 文件包含：

[omm@opengauss ~]$ tar -tvf backup/stone_backup.tar 
-rw------- 2048/1024      8598 2025-03-31 15:49 toc.dat
-rw------- 2048/1024        26 2025-03-31 15:49 4884.dat
-rw------- 2048/1024        26 2025-03-31 15:49 4885.dat
-rw------- 2048/1024         6 2025-03-31 15:49 4883.dat
-rw------- 2048/1024        33 2025-03-31 15:49 4875.dat
-rw------- 2048/1024        58 2025-03-31 15:49 4879.dat
-rw------- 2048/1024        16 2025-03-31 15:49 4880.dat
-rw------- 2048/1024        90 2025-03-31 15:49 4881.dat
-rw------- 2048/1024        36 2025-03-31 15:49 4882.dat
-rw------- 2048/1024      7757 2025-03-31 15:49 restore.sql

例子：导出 postgres 数据库中的 stone 模式的所有数据，以自定义文件格式保存到指定文件

[omm@opengauss ~]$ gs_dump -n stone -F c -f backup/stone_backup.dmp postgres
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: Finish scanning database. 
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: Start dumping objects 
Progress: [==================================================] 100% (4887/4887, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: Finish dumping objects 
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: dump database postgres successfully
gs_dump[port='15400'][postgres][2025-03-31 15:54:39]: total time: 295  ms

[omm@opengauss ~]$ ll backup/
total 48
-rw------- 1 omm dbgrp  9080 Mar 31 15:54 stone_backup.dmp
-rw------- 1 omm dbgrp  6781 Mar 31 15:41 stone_backup.sql
-rw------- 1 omm dbgrp 27136 Mar 31 15:49 stone_backup.tar

例子：导出 postgres 数据库中的 stone 模式的所有数据，以目录格式保存

[omm@opengauss ~]$ gs_dump -n stone -F d -f backup/stone_backup postgres
gs_dump[port='15400'][postgres][2025-03-31 15:57:11]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][postgres][2025-03-31 15:57:11]: Finish scanning database. 
gs_dump[port='15400'][postgres][2025-03-31 15:57:11]: Start dumping objects 
Progress: [==================================================] 100% (4887/4887, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][postgres][2025-03-31 15:57:12]: Finish dumping objects 
gs_dump[port='15400'][postgres][2025-03-31 15:57:12]: dump database postgres successfully
gs_dump[port='15400'][postgres][2025-03-31 15:57:12]: total time: 273  ms

导出的目录包含以下文件：

[omm@opengauss ~]$ ll backup/stone_backup
total 44
-rw------- 1 omm dbgrp   46 Mar 31 15:57 4875.dat.gz
-rw------- 1 omm dbgrp   53 Mar 31 15:57 4879.dat.gz
-rw------- 1 omm dbgrp   36 Mar 31 15:57 4880.dat.gz
-rw------- 1 omm dbgrp   81 Mar 31 15:57 4881.dat.gz
-rw------- 1 omm dbgrp   45 Mar 31 15:57 4882.dat.gz
-rw------- 1 omm dbgrp   26 Mar 31 15:57 4883.dat.gz
-rw------- 1 omm dbgrp   43 Mar 31 15:57 4884.dat.gz
-rw------- 1 omm dbgrp   43 Mar 31 15:57 4885.dat.gz
-rw------- 1 omm dbgrp    0 Mar 31 15:57 dir.lock
-rw------- 1 omm dbgrp 8622 Mar 31 15:57 toc.dat

gs_dumpall

gs_dumpall 是 openGauss 用于导出所有数据库相关信息工具，它可以导出 openGauss 数据库的所有数据，包括默认数据库 postgres 的数据、自定义数据库的数据以及 openGauss 所有数据库公共的全局对象。

gs_dumpall 工具由操作系统用户 omm 执行。
gs_dumpall 工具在进行数据导出时，其他用户可以访问 openGauss 数据库（读或写）。
gs_dumpall 工具支持导出完整一致的数据。例如，T1 时刻启动 gs_dumpall 导出 openGauss 数据库，那么导出数据结果将会是 T1 时刻该 openGauss 数据库的数据状态，T1 时刻之后对 openGauss 的修改不会被导出。
gs_dumpall 时生成列不会被转储。
gs_dumpall 在导出 openGauss 所有数据库时分为两部分：
- gs_dumpall 自身对所有数据库公共的全局对象进行导出，包括有关数据库用户和组、表空间以及属性（例如，适用于数据库整体的访问权限）信息。
- gs_dumpall 通过调用 gs_dump 来完成 openGauss 中各数据库的 SQL 脚本文件导出，该脚本文件包含将数据库恢复为其保存时的状态所需要的全部 SQL 语句。
以上两部分导出的结果为纯文本格式的 SQL 脚本文件，使用 gsql 运行该脚本文件可以恢复 openGauss 数据库。
gs_dumpall 工具支持使用过程中打印进度。会依次对每个数据库进行转存，每个数据库的流程中都与使用 gs_dump 时的进度打印相同。首先在对数据库的全局扫描阶段会打印扫描流程进行到具体哪一步。在转存数据阶段会根据已经完成的对象数比上总对象数打印进度。

注意：

禁止修改导出的文件和内容，否则可能无法恢复成功。
为了保证数据一致性和完整性，gs_dumpall 会对需要转储的表设置共享锁。如果某张表在别的事务中设置了共享锁，gs_dumpall 会等待此表的锁释放后锁定此表。如果无法在指定时间内锁定某张表，转储会失败。用户可以通过指定 --lock-wait-timeout 选项，自定义等待锁超时时间。
由于 gs_dumpall 读取所有数据库中的表，因此必须以 openGauss 管理员身份进行连接，才能导出完整文件。在使用 gsql 执行脚本文件导入时，同样需要管理员权限，以便添加用户和组以及创建数据库。

语法：

gs_dumpall [OPTION]...

通用参数：

-f, --file=FILENAME：将输出发送至指定文件或目录。如果省略该参数，则使用标准输出。
-v, --verbose：指定 Verbose 模式。该选项将导致 gs_dumpall 向转储文件输出详细的对象注解和启动/停止次数，向标准错误流输出处理信息。
--lock-wait-timeout=TIMEOUT：如果无法在指定时间内锁定某个表，就选择失败。可以以任何符合 SET statement_timeout 的格式指定超时时间。

导出参数：

-a, --data-only：只导出数据，不导出对象定义。
-s, --schema-only：只导出对象定义，不导出数据。
-c, --clean：在重新创建数据库之前，执行 SQL 语句清理（删除）这些数据库。针对角色和表空间的转储命令已添加。
-g, --globals-only：只转储全局对象（角色和表空间），无数据库。
-O, --no-owner：不输出设置对象的归属这样的命令，以匹配原始数据库。默认情况下，gs_dumpall 会发出 ALTER OWNER 或 SET SESSION AUTHORIZATION 语句设置所创建的模式元素的所属。如果脚本正在运行，该语句不会执行成功，除非是由系统管理员触发（或是拥有脚本中所有对象的同一个用户）。通过指定 -O，编写一个任何用户都能存储的脚本，且该脚本会授予该用户拥有所有对象的权限。
-r, --roles-only：只转储角色，不转储数据库或表空间。
-t, --tablespaces-only：只转储表空间，不转储数据库或角色。
-x, --no-privileges：防止转储访问权限（授权/撤销命令）。
--column-inserts/--attribute-inserts：以 INSERT 命令带列名方式导出数据。这会导致恢复缓慢。但是由于该选项会针对每行生成一个独立分开的命令，所以在重新加载某行时出现的错误只会导致那行丢失，而非整个表内容。
--disable-dollar-quoting：禁止在函数体前使用美元符号 $，并强制使用 SQL 标准字符串语法对其进行引用。
--inserts：发出 INSERT 命令（而非 COPY 命令）转储数据。这会导致恢复缓慢。注意：如果重排列顺序，可能会导致整个恢复失败。列顺序改变时，--column-inserts 选项不受影响，虽然会更慢。
--no-tablespaces：请勿输出创建表空间的命令，也请勿针对对象选择表空间。使用该选项，无论默认表空间是哪个，在恢复过程中所有对象都会被创建。

连接参数：

-h, --host=HOSTNAME：指定主机名称，缺省从 PGHOST 环境变量中获取。
-p, --port=PORT：指定主机端口，缺省从 PGPORT 环境变量中获取。
-l, --database=DATABASENAME：指定所连接的转储全局对象的数据库名称，并去寻找还有其他哪些数据库需要被转储。如果没有指定，会使用 postgres 数据库，如果 postgres 数据库不存在，会使用template1。
-U, --username=NAME：指定所连接主机的用户名，缺省从 PGUSER 环境变量中获取。
-w, --no-password：不出现输入密码提示。如果主机要求密码认证并且密码没有通过其它形式给出，则连接尝试将会失败。该选项在批量工作和不存在用户输入密码的脚本中很有帮助。
-W, --password=PASSWORD：指定用户连接的密码。
--role=ROLENAME：指定创建转储使用的角色名。选择该选项，会使 gs_dump 连接数据库后，发起一个 SET ROLE 角色名命令。当所授权用户（由 -U 指定）没有 gs_dump 要求的权限时，该选项会起到作用，即切换到具备相应权限的角色。某些安装操作规定不允许直接以超系统管理员身份登录，而使用该选项能够在不违反该规定的情况下完成转储。
--rolepassword=ROLEPASSWORD：指定角色名的密码。

注意：

由于 gs_dumpall 内部调用 gs_dump，所以一些诊断信息参见 gs_dump。
一旦恢复，最好在每个数据库上运行 ANALYZE，优化程序提供有用的统计数据。
gs_dumpall 恢复前需要所有必要的表空间目录为空；否则，对于处在非默认位置的数据库，数据库创建会失败。

例子：导出所有数据库

[omm@opengauss ~]$ gs_dumpall -f backup/all_backup.sql
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: Finish scanning database. 
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: Start dumping objects 
Progress: [==================================================] 100% (4887/4887, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: Finish dumping objects 
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: dump database dbname='postgres' successfully
gs_dump[port='15400'][dbname='postgres'][2025-03-31 16:50:37]: total time: 378  ms
gs_dumpall[port='15400'][2025-03-31 16:50:37]: dumpall operation successful
gs_dumpall[port='15400'][2025-03-31 16:50:37]: total time: 449  ms

导出的数据如下：

[omm@opengauss ~]$ cat backup/all_backup.sql 
--
-- openGauss database cluster dump
--

SET client_encoding = 'SQL_ASCII';
SET standard_conforming_strings = on;

--
-- Roles
--

CREATE ROLE omm PASSWORD 'sha25610b7f62fd88a11b0653c981784dfe3a08eb5be1418ca9ed56d96598b36cb463f699b2d64c6f38cb50208401d9b927c19982324ec0f35b184d3a1adfd3d3f2c660afbce4c6f3365f3aacc281b0af23e13a745428b23fc9709fee170ae79d33429ecdfecefade';
ALTER ROLE omm WITH SYSADMIN INHERIT CREATEROLE CREATEDB USEFT LOGIN REPLICATION AUDITADMIN MONADMIN OPRADMIN POLADMIN;
CREATE ROLE stone PASSWORD 'sha256e921c3197130b8536f219f78b54d6d53c4ec7c5904f5cd4e50cbd918925925bae121ac299fac5cf60608869bf01bab5bf0b25fb486ba71892966d5b04ec28fcb6da0bf10ea9f260e9fed3bfa80be57543f28a5e379b3769763de3a567c95f84becdfecefade';
ALTER ROLE stone WITH NOSYSADMIN INHERIT NOCREATEROLE NOCREATEDB NOUSEFT LOGIN NOREPLICATION NOAUDITADMIN;






--
-- Database creation
--

REVOKE ALL ON DATABASE postgres FROM PUBLIC;
REVOKE ALL ON DATABASE postgres FROM omm;
GRANT CREATE,CONNECT,TEMPORARY ON DATABASE postgres TO omm;
GRANT CONNECT,TEMPORARY ON DATABASE postgres TO PUBLIC;
GRANT CREATE,CONNECT,TEMPORARY ON DATABASE postgres TO stone;
GRANT ALTER,DROP,COMMENT ON DATABASE postgres TO stone;
REVOKE ALL ON DATABASE template1 FROM PUBLIC;
REVOKE ALL ON DATABASE template1 FROM omm;
GRANT CREATE,CONNECT,TEMPORARY ON DATABASE template1 TO omm;
GRANT CONNECT ON DATABASE template1 TO PUBLIC;


\connect postgres

--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'SQL_ASCII';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: postgres; Type: COMMENT; Schema: -; Owner: omm
--

COMMENT ON DATABASE postgres IS 'default administrative connection database';


--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


--
-- Name: stone; Type: SCHEMA; Schema: -; Owner: stone
--

CREATE SCHEMA stone;


ALTER SCHEMA stone OWNER TO stone;

SET search_path = stone;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: staff; Type: TABLE; Schema: stone; Owner: stone; Tablespace: 
--

CREATE TABLE staff (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no);


ALTER TABLE stone.staff OWNER TO stone;

--
-- Data for Name: staff; Type: TABLE DATA; Schema: stone; Owner: stone
--

COPY stone.staff (id, name, age, address, salary) FROM stdin;
1       lily            28      \N      \N
\.
;

--
-- Name: public; Type: ACL; Schema: -; Owner: omm
--

REVOKE ALL ON SCHEMA public FROM PUBLIC;
REVOKE ALL ON SCHEMA public FROM omm;
GRANT CREATE,USAGE ON SCHEMA public TO omm;
GRANT USAGE ON SCHEMA public TO PUBLIC;


--
-- openGauss database dump complete
--

--
-- openGauss database cluster dump complete
--

gs_restore

gs_restore 是 openGauss 提供的针对 gs_dump 导出数据的导入工具。通过此工具可将 gs_dump 生成的导出文件进行导入。

gs_restore 工具由操作系统用户 omm 执行。

gs_restore 工具目前支持进度打印，会根据已经恢复的对象数比上需要恢复的总对象数打印进度。

主要功能包含：

导入到数据库：如果连接参数中指定了数据库，则数据将被导入到指定的数据库中。其中，并行导入必须指定连接的密码。导入时生成列会自动更新，并像普通列一样保存。
导入到脚本文件：如果未指定导入数据库，则创建包含重建数据库所必须的 SQL 语句脚本并写入到文件或者标准输出。等效于直接使用 gs_dump 导出为纯文本格式。

语法：

gs_restore [OPTION]... FILE

注意：
FILE 没有短选项或长选项。用来指定归档文件所处的位置。
作为前提条件，需输入 dbname 或 -l 选项。不允许用户同时输入 dbname 和 -l 选项。
gs_restore 默认是以追加的方式进行数据导入。为避免多次导入造成数据异常，在进行导入时，建议使用 -c 参数，在重新创建数据库对象前，清理（删除）已存在于将要还原的数据库中的数据库对象。
日志打印无开关，若需隐藏日志，请将日志重定向到日志文件。若恢复表数据时，数据量很大，会分批恢复，因此会多次出现“表数据已完成导入”的日志。

通用参数：

-d, --dbname=NAME：连接数据库并直接导入到该数据库中。
-f, --file=FILENAME：指定生成脚本的输出文件，或使用 -l 时列表的输出文件。默认是标准输出。-f 不能同 -d 一起使用。
-l, --list：列出归档形式内容。这一操作的输出可用作 -L 选项的输入。注意如果像 -n 或 -t 的过滤选项与 -l 使用，过滤选项将会限制列举的项目（即归档形式内容）。
-v, --verbose：指定 Verbose 模式。

导入参数：

-a, --data-only：只导入数据，不导入模式（数据定义）。gs_restore 的导入是以追加方式进行的。
-c, --clean：在重新创建数据库对象前，清理（删除）已存在于将要还原的数据库中的数据库对象。
-C, --create：导入数据库之前会先使用 CREATE DATABASE 创建数据库。（指定该选项后，-d 指定的数据库仅用以执行 CREATE DATABASE 命令，所有数据依然会导入到创建的数据库中。）
-e, --exit-on-error：当发送 SQL 语句到数据库时如果出现错误，请退出。默认状态下会继续，且在导入后会显示一系列错误信息。
-I, --index=NAME：只导入已列出的索引。允许导入多个索引。
-j, --jobs=NUM：运行 gs_restore 最耗时的部分（如加载数据、创建索引或创建约束）使用并发任务。该选项能大幅缩短导入时间，即将一个大型数据库导入到某一多处理器的服务器上。
-L, --use-list=FILENAME：只导入列举在指定文件中的那些归档形式元素，导入顺序以它们在文件中的顺序为准。注意如果像 -n 或 -t 的过滤选项与 -L 使用，它们将会进一步限制导入的项目。
-n, --schema=NAME：只导入已列举的模式中的对象。该选项可与 -t 选项一起用以导入某个指定的表。
-O, --no-owner：不输出设置对象的归属这样的命令，以匹配原始数据库。默认情况下，gs_restore 会发出 ALTER OWNER 或 SET SESSION AUTHORIZATION 语句设置所创建的模式元素的所属。除非是由系统管理员（或是拥有脚本中所有对象的同一个用户）进行数据库首次连接的操作，否则语句会失败。使用 -O 选项，任何用户名都可用于首次连接，且该用户拥有所有已创建的对象。
-P, --function=NAME(args)：只导入已列举的函数。请按照函数所在转储文件中的目录，准确拼写函数名称和参数。当 -P 单独使用时，表示导入文件中所有 function-name(args) 函数；当 -P 同 -n 一起使用时，表示导入指定模式下的 function-name(args) 函数；多次输入 -P，而仅指定一次 -n，表示所有导入的函数默认都是位于 -n 模式下的。
-s, --schema-only：只导入模式（数据定义），不导入数据（表内容）。当前的序列值也不会导入。
-t, --table=NAME：只导入已列举的表定义、数据或定义和数据。该选项与 -n 选项同时使用时，用来指定某个模式下的表对象。-n 参数不输入时，默认为 PUBLIC 模式。多次输入 -n <schemaname> -t <tablename> 可以导入指定模式下的多个表。-t 不支持 schema_name.table_name，指定此格式不会报错，但不会生效。
-x, --no-privileges/--no-acl：防止导入访问权限。
-1, --single-transaction：执行导入作为一个单独事务（即把命令包围在 BEGIN/COMMIT 中）。

连接参数：

-h, --host=HOSTNAME：指定主机名称，缺省从 PGHOST 环境变量中获取。
-p, --port=PORT：指定主机端口，缺省从 PGPORT 环境变量中获取。
-U, --username=NAME：指定所连接主机的用户名，缺省从 PGUSER 环境变量中获取。
-w, --no-password：不出现输入密码提示。如果主机要求密码认证并且密码没有通过其它形式给出，则连接尝试将会失败。该选项在批量工作和不存在用户输入密码的脚本中很有帮助。
-W, --password=PASSWORD：指定用户连接的密码。
--role=ROLENAME：指定创建转储使用的角色名。选择该选项，会使 gs_dump 连接数据库后，发起一个 SET ROLE 角色名命令。当所授权用户（由 -U 指定）没有 gs_dump 要求的权限时，该选项会起到作用，即切换到具备相应权限的角色。某些安装操作规定不允许直接以超系统管理员身份登录，而使用该选项能够在不违反该规定的情况下完成转储。
--rolepassword=ROLEPASSWORD：指定角色名的密码。

例子：使用 gsql 导入由 gs_dump 或者 gs_dumpall 导出的 SQL 文件到 postgres 数据库

[omm@opengauss ~]$ gsql -d postgres -f backup/stone_backup.sql
SET
SET
SET
SET
SET
SET
SET
SET
COMMENT
SET
CREATE SCHEMA
ALTER SCHEMA
SET
SET
SET
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE SEQUENCE
ALTER SEQUENCE
ALTER SEQUENCE
CREATE SEQUENCE
ALTER SEQUENCE
ALTER SEQUENCE
CREATE SEQUENCE
ALTER SEQUENCE
ALTER SEQUENCE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
CREATE TABLE
ALTER TABLE
ALTER TABLE
ALTER TABLE
ALTER TABLE
 setval 
--------
      2
(1 row)

 setval 
--------
      2
(1 row)

 setval 
--------
      2
(1 row)

ALTER TABLE
ALTER TABLE
total time: 190  ms

例子：使用 gs_restore 导入 DMP 文件到 postgres 数据库

[omm@opengauss ~]$ gs_restore -d postgres backup/stone_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (36/36, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 104  ms

例子：使用 gs_restore 导入 TAR 文件到 postgres 数据库

[omm@opengauss ~]$ gs_restore -d postgres backup/stone_backup.tar
start restore operation ...
Progress: [==================================================] 100% (36/36, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 101  ms

例子：使用 gs_restore 导入目录格式下的文件到 postgres 数据库

[omm@opengauss ~]$ gs_restore -d postgres backup/stone_backup
start restore operation ...
Progress: [==================================================] 100% (36/36, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 108  ms

例子：使用 gs_restore 导入 DMP 文件中的 staff 表到 postgres 数据库的 stone 模式中

[omm@opengauss ~]$ gs_restore -d postgres -n stone -t staff -e -c backup/stone_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (36/36, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 24  ms

物理备份与恢复

gs_backup

openGauss 提供了 gs_backup 工具，用于数据库运行环境的备份，不包含实际数据文件。

前提条件：

可以正常连接 openGauss 数据库。
在进行还原时，需要保证各节点备份目录中存在备份文件。
需以操作系统用户 omm 执行 gs_backup 命令。

语法：

备份数据库：

gs_backup -t backup --backup-dir=BACKUPDIR [-h HOSTNAME] [--parameter]
                                             [--binary] [--all] [-l LOGFILE]

恢复数据库：

gs_backup -t restore --backup-dir=BACKUPDIR [-h HOSTNAME] [--parameter]
                                              [--binary] [--all] [-l LOGFILE]
                                              [--force]

其中：

-t：指定操作类型。backup 表示备份，restore 表示恢复。
--backup-dir：备份文件保存目录或者恢复文件所在目录。
-h HOSTNAME：若不指定，默认备份整个集群所有节点的数据；若指定节点名称（如 -h plat1），则仅备份该节点的文件。
--parameter：备份或者恢复参数文件，包括 postgresql.conf 和 pg_hba.conf。默认选项。
--binary：备份或者恢复数据库安装目录下的二进制工具脚本（位于 app 目录），包括数据库管理工具和核心程序文件。
--all：备份或者恢复参数文件和二进制文件。
-l LOGFILE：指定日志文件，默认为 $GAUSSLOG/om/gs_backup-YYYY-MM-DD_hhmmss.log。
--force：在集群静态配置文件丢失情况下强制恢复二进制文件。

例子：备份参数文件

[omm@opengauss ~]$ gs_backup -t backup --backup-dir=/home/omm/backup --parameter
Parsing configuration files.
Successfully parsed the configuration file.
Performing remote backup.
Remote backup succeeded.
Successfully backed up cluster files.

[omm@opengauss ~]$ ll backup/parameter.tar 
-rw------- 1 omm dbgrp 61440 Apr  1 15:09 backup/parameter.tar

例子：备份参数文件和二进制文件

[omm@opengauss ~]$ gs_backup -t backup --backup-dir=/home/omm/backup --all
Parsing configuration files.
Successfully parsed the configuration file.
Performing remote backup.
Remote backup succeeded.
Successfully backed up cluster files.

例子：恢复参数文件

[omm@opengauss ~]$ gs_backup -t restore --backup-dir=/home/omm/backup --parameter
Parsing configuration files.
Successfully parsed the configuration file.
Performing remote restoration.
Successfully restored cluster files.

例子：恢复参数文件和二进制文件

[omm@opengauss ~]$ gs_backup -t restore --backup-dir=/home/omm/backup --all
Parsing configuration files.
Successfully parsed the configuration file.
Performing remote restoration.
Successfully restored cluster files.

gs_probackup

gs_probackup 是一个用于管理 openGauss 数据库备份和恢复的工具。它对 openGauss 实例进行定期备份，以便在数据库出现故障时能够恢复服务器。

可用于备份单机数据库，也可对主机或者主节点数据库备机进行备份，为物理备份。
可备份外部目录的内容，如脚本文件、配置文件、日志文件、DUMP 文件等。
支持增量备份、定期备份和远程备份。
可设置备份的留存策略。
支持备份到兼容 S3 协议的对象存储。

gs_probackup 目前支持进度打印，会分别在文件备份、文件验证阶段、文件同步阶段以及文件恢复阶段，根据已经完成的文件数比总文件数打印进度。

前提条件：

可以正常连接 openGauss 数据库。
若要使用 PTRACK 增量备份，需在 postgresql.conf 中手动添加参数 enable_cbm_tracking = on 或通过 gs_guc 工具进行设置。
为了防止 XLOG 在传输结束前被清理，请适当调高 postgresql.conf 文件中 wal_keep_segments 的值。

限制说明：

备份必须由运行数据库服务器的用户执行。
备份和恢复的数据库服务器的主版本号必须相同。
如果要通过 SSH 在远程模式下备份数据库，需要在本地和远程主机安装相同主版本的数据库，并通过 ssh-copy-id remote_user@remote_host 命令设置本地主机备份用户和远程主机数据库用户的无密码 SSH 连接。
远程模式下只能执行 add-instance、backup、restore 子命令。
使用 restore 子命令前，应先停止 gaussdb 进程。
在非资源池化模式下，当存在用户自定义表空间时，如果该表空间的路径不在 $PGDATA 目录下，备份的时候要加上 --external-dirs 参数，否则，该表空间不会被备份；在资源池化模式下，当前只支持相对路径表空间，因此存在自定义表空间时不需要指定 --external-dir 参数。
当备份的规模比较大或在备份同时执行业务时，为了防止备份过程中发生超时，请适当调整 postgresql.conf 文件的参数 session_timeout、wal_sender_timeout。并且在备份的命令行参数中适当调整参数 --rw-timeout 的值。
资源池化模式下，恢复到不同集群需先执行全量恢复。
恢复时，使用 -T 选项把备份中的外部目录重定向到新目录时，请同时指定参数 --external-mapping。
增量备份恢复后，之前创建的非 PGOUTPUT 插件的逻辑复制槽不可用，需删除重建。
当使用远程备份时，请确保远程机器和备份机器的时钟同步，以防止使用 --recovery-target-time 恢复的场合,启动 gaussdb 时有可能会失败。
当远程备份有效时（remote-proto=ssh），请确保 -h 和 --remote-host 指定的是同一台机器。当远程备份无效时，如果指定了 -h 选项，请确保 -h 指定的是本机地址或本机主机名。
当前仅支持备份发布订阅的逻辑复制槽。
备份时，请确保服务器用户对备份的目录下所有文件有读写的权限，以防止在恢复时因权限不足的问题而失败。
在资源池化模式下当前仅支持本地主机操作。
备份将执行 Checkpoint 与 XLOG Switch 操作，此行为将产生新的 XLOG，并提交事务。一主一备或一主多备场景备份时，若配置文件中 synchronous_commit 设置为 on，备机关停可能会导致主机同步提交事务失败，进而导致备份失败。此场景下，请确认各节点状态正常，或将 synchronous_commit 设置为 off 以避免备份失败。
在开启 enable_cbm_tracking 后，不能直接执行增量备份，需要先执行全量备份，即使在开启参数之前已经执行过全量备份。
备份到兼容 S3 协议的对象存储时，请确保对象存储服务已经开通，可以获取到 ak 和 sk，并且已经创建好 Bucket。备份到对象存储特性目前不支持执行 merge 子命令。
不建议在服务器负载压力较大下执行备份操作，可能出现备份失败的现象。此时请降低服务器负载，之后重新执行备份。

命令说明：

打印 gs_probackup 版本。

gs_probackup -V|--version
gs_probackup version

显示 gs_probackup 命令的帮助信息。如果指定了 gs_probackup 的子命令，则显示可用于此子命令的参数的详细信息。

gs_probackup -?|--help
gs_probackup help [command]

初始化备份路径 backup-path 中的备份目录，该目录将存储已备份的内容。如果备份路径 backup-path 已存在，则 backup-path 必须为空目录。

gs_probackup init -B backup-path [--help]

在备份路径 backup-path 内初始化一个新的备份实例，并生成 pg_probackup.conf 配置文件，该文件保存了指定数据目录 pgdata-path 的 gs_probackup 设置。

gs_probackup add-instance -B backup-path -D pgdata-path --instance=instance_name
[-E external-directories-paths]
[remote_options] [dss_options] [s3_options]
[--help]

在备份路径 backup-path 内删除指定实例相关的备份内容。

gs_probackup del-instance -B backup-path --instance=instance_name
[s3_options]
[--help]

将指定的连接、压缩、日志等相关设置添加到 pg_probackup.conf 配置文件中，或修改已设置的值。不推荐手动编辑 pg_probackup.conf 配置文件。

gs_probackup set-config -B backup-path --instance=instance_name
[-D pgdata-path] [-E external-directories-paths] [--archive-timeout=timeout]
[--retention-redundancy=retention-redundancy] [--retention-window=retention-window] [--wal-depth=wal-depth]
[--compress-algorithm=compress-algorithm] [--compress-level=compress-level]
[-d dbname] [-h hostname] [-p port] [-U username]
[logging_options] [remote_options] [dss_options] [s3_options]
[--help]

将备份相关设置添加到 backup.control 配置文件中，或修改已设置的值。

gs_probackup set-backup -B backup-path --instance=instance_name -i backup-id
[--note=text] [pinning_options]
[s3_options] [--s3-status=s3|local]
[--help]

显示位于备份目录中的 pg_probackup.conf 配置文件的内容。可以通过指定 --format=json 选项，以 JSON 格式显示。默认情况下，显示为纯文本格式。

gs_probackup show-config -B backup-path --instance=instance_name
[--format=plain|json]
[s3_options]
[--help]

显示备份目录的内容。如果指定了 instance_name 和 backup_id，则显示该备份的详细信息。可以通过指定 --format=json 选项，以 JSON 格式显示。默认情况下，备份目录的内容显示为纯文本格式。

gs_probackup show -B backup-path
[--instance=instance_name [-i backup-id]] [--archive] [--format=plain|json]
[s3_options]
[--help]

创建指定实例的备份。

gs_probackup backup -B backup-path --instance=instance_name -b backup-mode
[-D pgdata-path] [-C] [-S slot-name] [--temp-slot] [--backup-pg-log] [-j threads_num] [--progress]
[--no-validate] [--skip-block-validation] [-E external-directories-paths] [--no-sync] [--note=text]
[--archive-timeout=timeout] [-t rwtimeout]
[logging_options] [retention_options] [compression_options] [connection_options]
[remote_options] [dss_options] [pinning_options] [s3_options][--backup-pg-replslot]
[--help]

从备份目录 backup-path 中的备份副本恢复指定实例。使用 restore 子命令前，应先停止 gaussdb 进程，如果指定了恢复目标选项，gs_probackup 将查找最近的备份并将其还原到指定的恢复目标。否则，使用最近一次备份。

gs_probackup restore -B backup-path --instance=instance_name
[-D pgdata-path] [-i backup_id] [-j threads_num] [--progress] [--force] [--no-sync] [--no-validate] [--skip-block-validation]
[--external-mapping=OLDDIR=NEWDIR] [-T OLDDIR=NEWDIR] [--skip-external-dirs] [-I incremental_mode]
[recovery_options] [remote_options] [dss_options] [logging_options] [s3_options]
[--help]

将指定的增量备份与其父完全备份之间的所有增量备份合并到父完全备份。父完全备份将接收所有合并的数据，而已合并的增量备份将作为冗余被删除。

gs_probackup merge -B backup-path --instance=instance_name -i backup_id
[-j threads_num] [--progress] [logging_options]
[--help]

删除指定备份，或删除不满足当前保留策略的备份。

gs_probackup delete -B backup-path --instance=instance_name
[-i backup-id | --delete-expired | --merge-expired | --status=backup_status]
[--delete-wal] [-j threads_num] [--progress]
[--retention-redundancy=retention-redundancy] [--retention-window=retention-window]
[--wal-depth=wal-depth] [--dry-run]
[logging_options] [s3_options]
[--help]

验证恢复数据库所需的所有文件是否存在且未损坏。如果未指定 instance_name，gs_probackup 将验证备份目录中的所有可用备份。如果指定 instance_name 而不指定任何附加选项，gs_probackup 将验证此备份实例的所有可用备份。如果指定了 instance_name 并且指定 backup-id 或恢复目标相关选项，gs_probackup 将检查是否可以使用这些选项恢复数据库。

gs_probackup validate -B backup-path
[--instance=instance_name] [-i backup-id]
[-j threads_num] [--progress] [--skip-block-validation]
[--recovery-target-time=time | --recovery-target-xid=xid | --recovery-target-lsn=lsn | --recovery-target-name=target-name]
[--recovery-target-inclusive=boolean]
[logging_options] [s3_options]
[--help]

通用参数：

command：gs_probackup 除 version 和 help 以外的子命令：init、add-instance、del-instance、set-config、set-backup、show-config、show、backup、restore、merge、delete、validate。
-?, --help：显示 gs_probackup 命令行参数的帮助信息，然后退出。子命令中只能使用 --help，不能使用 -?。
-V, --version：打印 gs_probackup 版本，然后退出。
-B backup-path, --backup-path=backup-path：备份的路径。缺省从 BACKUP_PATH 环境变量中获取。
-D pgdata-path, --pgdata=pgdata-path：数据目录的路径。缺省从 PGDATA 环境变量中获取。
--instance=instance_name：实例名。
-i backup-id, --backup-id=backup-id：备份的唯一标识。
--format=format：指定显示备份信息的格式，支持 plain 和 json 格式。默认为 plain。
--status=backup_status：删除指定状态的所有备份，包含以下状态：
- OK：备份已完成且有效。
- DONE：备份已完成但未经过验证。
- RUNNING：备份正在进行中。
- MERGING：备份正在合并中。
- DELETING：备份正在删除中。
- CORRUPT：部分备份文件已损坏。
- ERROR：由于意外错误，备份失败。
- ORPHAN：由于其父备份之一已损坏或丢失，备份无效。
-j threads_num, --threads=threads_num：设置备份、还原、合并进程的并行线程数。
--archive：显示 WAL 归档信息。
--progress：显示进度。
--note=text：给备份添加注释。

备份参数：

-b backup-mode, --backup-mode=backup-mode：指定备份模式，支持 FULL 和 PTRACK。
- FULL：创建全量备份，全量备份包含所有数据文件。
- PTRACK：创建 PTRACK 增量备份。
-C, --smooth-checkpoint：将检查点在一段时间内展开。默认情况下，gs_probackup 会尝试尽快完成检查点。
-S slot-name, --slot=slot-name：指定 WAL 流处理的复制 SLOT。
--temp-slot：在备份的实例中为 WAL 流处理创建一个临时物理复制 SLOT，它确保在备份过程中，所有所需的 WAL 段仍然是可用的。默认的 SLOT 名为 pg_probackup_slot，可通过选项 --slot/-S 更改。
--backup-pg-log：将日志目录包含到备份中。此目录通常包含日志消息。默认情况下包含日志目录，但不包含日志文件。如果修改了默认的日志路径，需要备份日志文件时可使用 -E 参数进行备份，使用方法见下文。
-E external-directories-paths, --external-dirs=external-directories-paths：将指定的目录包含到备份中。此选项对于备份位于数据目录外部的脚本、SQL 转储和配置文件很有用。如果要备份多个外部目录，请在 Unix 上用冒号分隔它们的路径。目前只支持指定文件系统中的目录，不支持指定共享存储中的目录。例如：-E /tmp/dir1:/tmp/dir2。
--skip-block-validation：关闭块级校验，加快备份速度。
--no-validate：在完成备份后跳过自动验证。
--no-sync：不将备份文件同步到磁盘。
--archive-timeout=timeout：以秒为单位设置流式处理的超时时间。默认为 300。
-t rwtimeout：以秒为单位的连接的超时时间。默认为 120。

恢复参数：

-I, --incremental-mode=none|checksum|lsn：若 PGDATA 中可用的有效页没有修改，则重新使用它们。默认为 none。
--external-mapping=OLDDIR=NEWDIR：在恢复时，将包含在备份中的外部目录从 OLDDIR 重新定位到 NEWDIR 目录。OLDDIR 和 NEWDIR 都必须是绝对路径。如果路径中包含 =，则使用反斜杠转义。此选项可为多个目录多次指定。目前只支持指定文件系统中的目录，不支持指定共享存储中的目录。
-T OLDDIR=NEWDIR, --tablespace-mapping=OLDDIR=NEWDIR：在恢复时，将表空间从 OLDDIR 重新定位到 NEWDIR 目录。OLDDIR 和 NEWDIR 必须都是绝对路径。如果路径中包含 =，则使用反斜杠转义。多个表空间可以多次指定此选项。此选项必须和 --external-mapping 一起使用。目前只支持指定文件系统中的目录，不支持指定共享存储中的目录。
--skip-external-dirs：跳过备份中包含的使用 --external-dirs 选项指定的外部目录。这些目录的内容将不会被恢复。
--skip-block-validation：跳过块级校验，以加快验证速度。在恢复之前的自动验证期间，将仅做文件级别的校验。
--no-validate：跳过备份验证。
--force：允许忽略备份的无效状态。如果出于某种原因需要从损坏的或无效的备份中恢复数据，可以使用此标志。请谨慎使用。

恢复目标参数（recovery_options）：

--recovery-target-lsn=lsn：指定要恢复到的 LSN，当前只能指定备份的 STOP LSN。
--recovery-target-name=target-name：指定要将数据恢复到的已命名的保存点，保存点可以通过查看备份中 recovery-name 字段得到。
--recovery-target-time=time：指定要恢复到的时间，当前只能指定备份中的 recovery-time。
--recovery-target-xid=xid：指定要恢复到的事务 ID，当前只能指定备份中的 recovery-xid。
--recovery-target-inclusive=boolean：当该参数指定为 true 时，恢复目标将包括指定的内容。当该参数指定为 false 时，恢复目标将不包括指定的内容。该参数必须和 --recovery-target-name、--recovery-target-time、--recovery-target-lsn 或 --recovery-target-xid 一起使用。

留存参数（retention_options），用于 backup 和 delete 命令：

--retention-redundancy=retention-redundancy：指定在数据目录中留存的完整备份数。必须为正整数。0 表示禁用此设置。默认值为 0。
--retention-window=retention-window：指定留存的天数。必须为正整数。0 表示禁用此设置。默认值为 0。
--wal-depth=wal-depth：每个时间轴上必须留存的执行 PITR 能力的最新有效备份数。必须为正整数。0 表示禁用此设置。默认值为 0。
--delete-wal：从任何现有的备份中删除不需要的 WAL 文件。
--delete-expired：删除不符合 pg_probackup.conf 配置文件中定义的留存策略的备份。
--merge-expired：将满足留存策略要求的最旧的增量备份与其已过期的父备份合并。
--dry-run：显示所有可用备份的当前状态，不删除或合并过期备份。

固定备份参数（pinning_options），用于 backup 和 set-backup 命令：

--ttl=interval：指定从恢复时间开始计算，备份要固定的时间量。必须为正整数。0 表示取消备份固定。支持的单位：ms， s， min， h， d（默认为 s）。例如 --ttl=30d。
--expire-time=time：指定备份固定失效的时间戳。必须是 ISO-8601 标准的时间戳。例如 --expire-time='2020-01-01 00:00:00+03'。

日志参数（logging_options）：

日志级别：verbose、log、info、warning、error 和 off。
--log-level-console=log-level-console：设置要发送到控制台的日志级别。每个级别都包含其后的所有级别。级别越高，发送的消息越少。指定 off 级别表示禁用控制台日志记录。默认值为 info。
--log-level-file=log-level-file：设置要发送到日志文件的日志级别。每个级别都包含其后的所有级别。级别越高，发送的消息越少。指定 off 级别表示禁用日志文件记录。默认值为 off。
--log-filename=log-filename：指定要创建的日志文件的文件名。文件名可以使用 strftime 模式，因此可以使用 %-escapes 指定随时间变化的文件名。例如，如果指定了 pg_probackup-%u.log 模式，则 pg_probackup 为每周的每一天生成单独的日志文件，其中 %u 替换为相应的十进制数字，即 pg_probackup-1.log 表示星期一；pg_probackup-2.log 表示星期二，以此类推。如果指定了 --log-level-file 参数启用日志文件记录，则该参数有效。默认值为 pg_probackup.log。
--error-log-filename=error-log-filename：指定仅用于 error 日志的日志文件名。指定方式与 --log-filename 参数相同。此参数用于故障排除和监视。
--log-directory=log-directory：指定创建日志文件的目录。必须是绝对路径。此目录会在写入第一条日志时创建。默认值为 $BACKUP_PATH/log。
--log-rotation-size=log-rotation-size：指定单个日志文件的最大大小。如果达到此值，则启动 gs_probackup 命令后，日志文件将循环，但 help 和 version 命令除外。0 表示禁用基于文件大小的循环。支持的单位：KB、MB、GB、TB（默认为 KB）。默认值为 0。
--log-rotation-age=log-rotation-age：单个日志文件的最大生命周期。如果达到此值，则启动 gs_probackup 命令后，日志文件将循环，但 help 和 version 命令除外。$BACKUP_PATH/log/log_rotation 目录下保存最后一次创建日志文件的时间。0 表示禁用基于时间的循环。支持的单位：ms，s，min，h，d（默认为 min）。默认值为 0。

连接参数（connection_options），用于 backup 命令：

-d dbname, --pgdatabase=dbname：指定要连接的数据库名称。该连接仅用于管理备份进程，因此您可以连接到任何现有的数据库。如果命令行、PGDATABASE 环境变量或 pg_probackup.conf 配置文件中没有指定此参数，则 gs_probackup 会尝试从 PGUSER 环境变量中获取该值。如果未设置 PGUSER 变量，则从当前用户名获取。
-h hostname, --pghost=hostname：指定运行服务器的系统的主机名。如果该值以斜杠开头，则被用作到 Unix 域套接字的路径。可以从 PGHOST 环境变量中获取。默认值为本地 Socket。
-p port, --pgport=port：指定服务器正在侦听连接的 TCP 端口或本地 Unix 域套接字文件扩展名。可以从 PGPORT 环境变量中获取。默认值为 5432。
-U username, --pguser=username：指定所连接主机的用户名。可以从 PGUSER 环境变量中获取。
-w, --no-password：不出现输入密码提示。如果主机要求密码认证并且密码没有通过其它形式给出，则连接尝试将会失败。该选项在批量工作和不存在用户输入密码的脚本中很有帮助。
-W password, --password=password：指定用户连接的密码。如果主机的认证策略是 trust，则不会对系统管理员进行密码验证，即无需输入 -W 选项；如果没有 -W 选项，并且不是系统管理员，则会提示用户输入密码。

压缩参数（compression_options），用于 backup 命令：

--compress-algorithm=compress-algorithm：指定用于压缩数据文件的算法。取值包括 zlib、pglz 和 none。如果设置为 zlib 或 pglz，此选项将启用压缩。默认情况下，压缩功能处于关闭状态。默认值为 none 。
--compress-level=compress-level：指定压缩级别。取值范围：0~9，默认值为 1：
- 0 表示无压缩。
- 1 表示压缩比最小，处理速度最快。
- 9 表示压缩比最大，处理速度最慢。
- 可与 --compress-algorithm 选项一起使用。
--compress：以 --compress-algorithm=zlib 和 --compress-level=1 进行压缩。

远程模式参数（remote_options），用于 add-instance、set-config、backup 和 restore 命令：

--remote-proto=protocol：指定用于远程操作的协议。目前只支持 SSH 协议。取值包括：
- ssh：通过 SSH 启用远程备份模式。这是默认值。
- none：显式禁用远程模式。
- 如果指定了 --remote-host 参数，可以省略此参数。
--remote-host=destination：指定要连接的远程主机的 IP 地址或主机名。
--remote-port=port：指定要连接的远程主机的端口号。默认为 22。
--remote-user=username：指定 SSH 连接的远程主机用户。如果省略此参数，则使用当前发起 SSH 连接的用户。默认值为当前用户。
--remote-path=path：指定 gs_probackup 在远程系统的安装目录。默认值为当前路径。
--remote-libpath=libpath：指定 gs_probackup 在远程系统安装的 LIB 库目录。
--ssh-options=ssh_options：指定 SSH 命令行参数的字符串。例如 --ssh-options='-c cipher_spec -F configfile'。

兼容 S3 协议对象存储参数（s3_options）：

--media-type=type：指定存储备份的介质类型。取值包括：
- s3：备份到兼容 S3 协议的对象存储。
- disk：备份到磁盘，不启用备份到对象存储的功能。这是默认值。
- 不需要备份到远程对象存储时，可以省略此参数。
--access-id=ak：开通对象存储服务后获取的 Access Key Id，用于标示用户。设置 media-type 为 s3 时不可为空。
--access-key=sk：开通对象存储服务后获取的 Secret Access Key，用于验证用户身份的密钥。设置 media-type 为 s3 时不可为空。
--access-bucket=bucket：用户在对象存储上创建的桶的名字。设置 media-type 为 s3 时不可为空。
--endpoint=endpoint：访问兼容 S3 协议对象存储的访问域名，可以是 ip:port 的形式。设置 media-type 为 s3 时不可为空。
--region=region：对象存储服务的地理区域，可选参数。值可以为空。
--s3-status=status：当前备份集的状态，取值包括：
- s3：备份集位于兼容 S3 协议的对象存储服务器上，此时执行 restore/validate 子命令将从对象存储下载回备份集文件。
- local：备份集已从对象存储下载回本地，此时执行 restore/validate 子命令将优先读取本地文件，如果本地文件不能正常恢复/验证将会报错。
- unknown：未设置 media-type 为 s3 时进行备份的备份集状态，无实际意义。
- 可通过 set-backup 子命令进行设置，通过 show 子命令查看。

备份流程（非资源池化模式）：

初始化备份目录。在指定的目录下创建 backups 和 wal 子目录，分别用于存放备份文件和 WAL 文件。

gs_probackup init -B backup_dir

注意：
在非资源池化模式下，虽然指定目录下会创建 wal 子目录，但 WAL 文件（即 pg_xlog 文件）会存放在 backups 目录下。

添加一个新的备份实例。gs_probackup 可以在同一个备份目录下存放多个数据库实例的备份。

gs_probackup add-instance -B backup_dir -D data_dir --instance instance_name

创建指定实例的备份。在进行增量备份之前，必须至少创建一次全量备份。

gs_probackup backup -B backup_dir --instance instance_name -b backup_mode

从指定实例的备份中恢复数据。

gs_probackup restore -B backup_dir --instance instance_name -D pgdata-path -i backup_id

注意：
在恢复备份前，必须先停止 gaussdb 进程，并且将原始实例目录（参数 -D 后面的目录）下面的内容清空。使用 restore 子命令前，应先停止 gaussdb 进程。

例子：备份数据库

[omm@opengauss ~]$ mkdir probackup
[omm@opengauss ~]$ gs_probackup init -B /home/omm/probackup/
INFO: Backup catalog '/home/omm/probackup' successfully inited

[omm@opengauss ~]$ gs_probackup add-instance -B /home/omm/probackup/ --instance dbCluster
INFO: Instance 'dbCluster' successfully inited

[omm@opengauss ~]$ gs_probackup backup -B /home/omm/probackup/ --instance dbCluster -b full
INFO: Backup start, gs_probackup version: 2.4.2, instance: dbCluster, backup ID: SU2U0B, backup mode: FULL, wal mode: STREAM, remote: false, compress-algorithm: none, compress-level: 1
LOG: Backup destination is initialized
LOG: This openGauss instance was initialized with data block checksums. Data block corruption will be detected
LOG: Database backup start
LOG: started streaming WAL at 0/3000000 (timeline 1)
[2025-04-02 14:00:13]: check identify system success                                                
[2025-04-02 14:00:13]: send START_REPLICATION 0/3000000 success                                     
[2025-04-02 14:00:13]: keepalive message is received                                                
INFO: PGDATA size: 605MB
INFO: Start backing up files
LOG: Creating page header map "/home/omm/probackup/backups/dbCluster/SU2U0B/page_header_map"
[2025-04-02 14:00:14]: keepalive message is received                                                
[2025-04-02 14:00:18]: keepalive message is received                                                
Progress: [==============================================    ] 92% (1455/1578, done_files/tot                                       [2025-04-02 14:00:23]: keepalive message is received         
[2025-04-02 14:00:29]: keepalive message is received                                                
Progress: [================================================= ] 9                                                                    [2025-04-02 14:00:35]: keepalive message is received
Progress: [==================================================] 100% (1578/1578, done_files/total_files). backup file 
[2025-04-02 14:00:40]: keepalive message is received                                                
[2025-04-02 14:00:45]: keepalive message is received                                                
[2025-04-02 14:00:51]: keepalive message is received                                                
[2025-04-02 14:00:56]: keepalive message is received                                                
INFO: Finish backuping file
INFO: Data files are transferred, time elapsed: 43s
INFO: wait for pg_stop_backup()
INFO: pg_stop backup() successfully executed
LOG: stop_lsn: 0/30001E8
LOG: Looking for LSN 0/30001E8 in segment: 000000010000000000000003
LOG: Found WAL segment: /home/omm/probackup/backups/dbCluster/SU2U0B/database/pg_xlog/000000010000000000000003
LOG: Thread [0]: Opening WAL segment "/home/omm/probackup/backups/dbCluster/SU2U0B/database/pg_xlog/000000010000000000000003"
LOG: Found LSN: 0/30001E8
LOG: finished streaming WAL at 0/4000000 (timeline 1)
LOG: Getting the Recovery Time from WAL
LOG: Thread [0]: Opening WAL segment "/home/omm/probackup/backups/dbCluster/SU2U0B/database/pg_xlog/000000010000000000000003"
INFO: Syncing backup files to disk
Progress: [==================================================] 100% (1578/1578, done_files/total_files). Sync backup file 
INFO: Finish Syncing backup files.
INFO: Backup files are synced, time elapsed: 2s
INFO: Validating backup SU2U0B
INFO: Begin validate file
Progress: [==================================================] 100% (1580/1580, done_files/total_files). validate file 
INFO: Finish validate file. 
INFO: Backup SU2U0B data files are valid
INFO: Backup SU2U0B resident size: 621MB
INFO: Backup SU2U0B completed

例子：恢复数据库

[omm@opengauss ~]$ gs_om -t stop

Stopping cluster.
=========================================
Successfully stopped cluster.
=========================================
End stop cluster.

[omm@opengauss ~]$ cd $PGDATA
[omm@opengauss dn]$ rm -fr *

[omm@opengauss dn]$ gs_probackup restore -B /home/omm/probackup/ --instance dbCluster -i SU2U0B
LOG: Restore begin.
LOG: there is no file tablespace_map
LOG: check tablespace directories of backup SU2U0B
LOG: check external directories of backup SU2U0B
INFO: Validating backup SU2U0B
INFO: Begin validate file
Progress: [==================================================] 100% (1580/1580, done_files/total_files). validate file 
INFO: Finish validate file. 
INFO: Backup SU2U0B data files are valid
LOG: Thread [1]: Opening WAL segment "/home/omm/probackup/backups/dbCluster/SU2U0B/database/pg_xlog/000000010000000000000003"
INFO: Backup SU2U0B WAL segments are valid
INFO: Backup SU2U0B is valid.
INFO: Restoring the database from backup at 2025-04-02 14:00:11+08
LOG: there is no file tablespace_map
LOG: Restore directories and symlinks... in /opt/huawei/install/data/dn
INFO: Start restoring backup files. DATA size: 621MB
INFO: Begin restore file
Progress: [==================================================] 100% (1580/1580, done_files/total_files). Restore file 
INFO: Finish restore file
INFO: Backup files are restored. Transfered bytes: 621MB, time elapsed: 1s
INFO: Restore incremental ratio (less is better): 100% (621MB/621MB)
INFO: Start Syncing restored files to disk
Progress: [==================================================] 100% (1580/1580, done_files/total_files). Sync restore file 
INFO: Finish Syncing restored files.
INFO: Restored backup files are synced, time elapsed: 10s
INFO: Restore of backup SU2U0B completed.

闪回恢复

闪回恢复功能是数据库恢复技术的一环，可以有选择性的撤销一个已提交事务的影响，将数据从人为不正确的操作中进行恢复。在采用闪回技术之前，只能通过备份恢复、PITR 等手段找回已提交的数据库修改，恢复时长需要数分钟甚至数小时。采用闪回技术后，恢复已提交的数据库修改前的数据，只需要秒级，而且恢复时间和数据库大小无关。

创建表时如果不指定存储引擎类型，默认为 ASTORE，表示表支持 Append-Only 存储引擎，但这种存储引擎暂不支持闪回。故要使表支持闪回，需要在创建表时指定存储引擎为 USTORE（with (storage_type=ustore)），表示表支持 Inplace-Update 存储引擎，USTORE 存储引擎结合 UNDO 空间，可以实现更高效、更全面的闪回查询和回收站机制。也可以修改参数 enable_default_ustore_table 为 on，指定用户创建表时默认使用 USTORE 存储引擎。

[omm@opengauss ~]$ gs_guc reload -c "enable_default_ustore_table = on"
The gs_guc run with the following arguments: [gs_guc -c enable_default_ustore_table = on reload ].
NOTICE: Enable to create ustore table by default
expected instance path: [/opt/huawei/install/data/dn/postgresql.conf]
gs_guc reload: enable_default_ustore_table=on: [/opt/huawei/install/data/dn/postgresql.conf]
server signaled

Total instances: 1. Failed instances: 0.
Success to perform gs_guc!

闪回恢复包括：

闪回查询
闪回表
闪回删除

闪回查询

闪回查询可以查询过去某个时间点表的某个快照数据，这一特性可用于查看和逻辑重建意外删除或更改的受损数据。闪回查询基于 MVCC 多版本机制，通过检索查询旧版本，获取指定老版本数据。

启用闪回查询需要先配置参数 undo_retention_time 以设置 UNDO 日志保留时间（以秒为单位）：

[omm@opengauss ~]$ gs_guc reload -c "undo_retention_time = 86400"
The gs_guc run with the following arguments: [gs_guc -c undo_retention_time = 86400 reload ].
NOTICE: Sets the maximum retention time of undo
expected instance path: [/opt/huawei/install/data/dn/postgresql.conf]
gs_guc reload: undo_retention_time=86400: [/opt/huawei/install/data/dn/postgresql.conf]
server signaled

Total instances: 1. Failed instances: 0.
Success to perform gs_guc!

语法：

{[ ONLY ] table_name [ * ] [ partition_clause ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
[ TABLESAMPLE sampling_method ( argument [, ...] ) [ REPEATABLE ( seed ) ] ]
[TIMECAPSULE { TIMESTAMP | CSN } expression ]
|( select ) [ AS ] alias [ ( column_alias [, ...] ) ]
|with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ]
|function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ]
|function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] )
|from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ]}

其中：

TIMESTAMP：指要查询某个表在 TIMESTAMP 这个时间点上的数据，TIMESTAMP 指一个具体的历史时间。
CSN：指要查询整个数据库逻辑提交序下某个 CSN 点的数据，CSN 指一个具体逻辑提交时间点，数据库中的 CSN 为写一致性点，每个 CSN 代表整个数据库的一个一致性点，查询某个 CSN 下的数据代表 SQL 查询数据库在该一致性点的相关数据。

例子：闪回查询

stone@postgres=> CREATE TABLE emp(
   ID             INT        NOT NULL,
   NAME           char(8)    NOT NULL,
   AGE            INT,
   ADDRESS        CHAR(50),
   SALARY         REAL
);
CREATE TABLE

stone@postgres=> \d+ emp;
                              Table "stone.emp"
 Column  |     Type      | Modifiers | Storage  | Stats target | Description 
---------+---------------+-----------+----------+--------------+-------------
 id      | integer       | not null  | plain    |              | 
 name    | character(8)  | not null  | extended |              | 
 age     | integer       |           | plain    |              | 
 address | character(50) |           | extended |              | 
 salary  | real          |           | plain    |              | 
Has OIDs: no
Options: orientation=row, compression=no, storage_type=ustore

stone@postgres=> INSERT INTO emp VALUES (1,'lily',28);
INSERT 0 1

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

stone@postgres=> select now();
              now              
-------------------------------
 2025-04-02 15:57:31.089798+08
(1 row)

stone@postgres=> update emp set age=30 where id=1;
UPDATE 1

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  30 |         |       
(1 row)

-- 闪回查询
stone@postgres=> SELECT * FROM emp TIMECAPSULE TIMESTAMP to_timestamp ('2025-04-02 15:57:31.089798', 'YYYY-MM-DD HH24:MI:SS.FF');
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

闪回表

闪回表可以将表恢复至特定时间点，当逻辑损坏仅限于一个或一组表，而不是整个数据库时，此特性可以快速恢复表的数据。闪回表基于 MVCC 多版本机制，通过删除指定时间点和该时间点之后的增量数据，并找回指定时间点和当前时间点删除的数据，实现表级数据还原。

启用闪回表同样需要设置 undo_retention_time 参数。

语法：

TIMECAPSULE TABLE table_name TO { TIMESTAMP | CSN } expression

例子：闪回表

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  30 |         |       
(1 row)

-- 闪回表
stone@postgres=> TIMECAPSULE TABLE emp TO TIMESTAMP to_timestamp ('2025-04-02 15:57:31.089798', 'YYYY-MM-DD HH24:MI:SS.FF');
TimeCapsule Table

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

闪回删除

闪回删除包括：

闪回 DROP：可以恢复意外删除的表，从回收站（Recyclebin）中恢复被删除的表及其附属结构如索引、表约束等。闪回 DROP 是基于回收站机制，通过还原回收站中记录的表的物理文件，实现已 DROP 表的恢复。
闪回 TRUNCATE：可以恢复误操作或意外被进行 TRUNCATE 的表，从回收站中恢复被 TRUNCATE 的表及索引的物理数据。闪回 TRUNCATE 基于回收站机制，通过还原回收站中记录的表的物理文件，实现已 TRUNCATE 表的恢复。

启用闪回删除需要设置参数 enable_recyclebin 以启用回收站，并设置参数 recyclebin_retention_time 指定回收站对象保留时间，超过该时间的回收站对象无法进行闪回恢复操作并将被自动清理。

[omm@opengauss ~]$ gs_guc reload -c "enable_recyclebin = on"
The gs_guc run with the following arguments: [gs_guc -c enable_recyclebin = on reload ].
NOTICE: Enable recyclebin for user-defined objects restore
expected instance path: [/opt/huawei/install/data/dn/postgresql.conf]
gs_guc reload: enable_recyclebin=on: [/opt/huawei/install/data/dn/postgresql.conf]
server signaled

Total instances: 1. Failed instances: 0.
Success to perform gs_guc!

[omm@opengauss ~]$ gs_guc reload -c "recyclebin_retention_time = 86400"
The gs_guc run with the following arguments: [gs_guc -c recyclebin_retention_time = 86400 reload ].
NOTICE: Sets the maximum retention time of objects in recyclebin
expected instance path: [/opt/huawei/install/data/dn/postgresql.conf]
gs_guc reload: recyclebin_retention_time=86400: [/opt/huawei/install/data/dn/postgresql.conf]
server signaled

Total instances: 1. Failed instances: 0.
Success to perform gs_guc!

语法：

删除表：

DROP TABLE table_name [PURGE]

清理回收站对象：

PURGE { TABLE { table_name }
| INDEX { index_name }
| RECYCLEBIN
}

闪回被删除的表：

TIMECAPSULE TABLE { table_name } TO BEFORE DROP [RENAME TO new_tablename]

截断表：

TRUNCATE TABLE { table_name } [ PURGE ]

闪回截断的表：

TIMECAPSULE TABLE { table_name } TO BEFORE TRUNCATE

例子：闪回删除的表

stone@postgres=> drop table emp;
DROP TABLE

stone@postgres=> select * from emp;
ERROR:  relation "emp" does not exist on dn_6001
LINE 1: select * from emp;
                      ^
-- 闪回删除的表
stone@postgres=> TIMECAPSULE TABLE emp TO BEFORE DROP;
TimeCapsule Table

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

例子：闪回截断的表

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

stone@postgres=> truncate table emp;
TRUNCATE TABLE

stone@postgres=> select * from emp;
 id | name | age | address | salary 
----+------+-----+---------+--------
(0 rows)

-- 闪回截断的表
stone@postgres=> TIMECAPSULE TABLE emp TO BEFORE TRUNCATE;
TimeCapsule Table

stone@postgres=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

导出数据

概述

openGauss 提供的 gs_dump 和 gs_dumpall 工具，能够帮助用户导出需要的数据库对象或其相关信息。通过导入工具将导出的数据信息导入至需要的数据库，可以完成数据库信息的迁移。gs_dump 支持导出单个数据库或其内的对象，而 gs_dumpall 支持导出 openGauss 中所有数据库或各库的公共全局对象。

gs_dump 和 gs_dumpall 对比如下：

工具	适用场景	支持的导出粒度	支持的导出格式	配套的导入方法
gs_dumpopen in new window	导出单个数据库	数据库级导出： 1. 导出全量信息。使用导出的全量信息可以创建一个与当前库相同的数据库，且库中数据也与当前库相同。 2. 仅导出库中所有对象的定义，包含库定义、函数定义、模式定义、表定义、索引定义和存储过程定义等。使用导出的对象定义，可以快速创建一个相同的数据库，但是库中并无原数据库的数据。 3. 仅导出数据。模式级导出： 1. 导出模式的全量信息。 2. 仅导出模式中数据。 3. 仅导出对象的定义，包含表定义、存储过程定义和索引定义等。表级导出： 1. 导出表的全量信息。 2. 仅导出表中数据。 3. 仅导出表的定义。	纯文本格式自定义归档格式目录归档格式 TAR 归档格式	纯文本格式数据文件导入使用 `gsql`工具自定义归档格式、目录归档格式和 TAR 归档格式数据文件导入使用 `gs_restore`
gs_dumpallopen in new window	导出所有数据库	数据库级导出： 1. 使用导出的全量信息可以创建与当前主机相同的一个主机环境，拥有相同数据库和公共全局对象，且库中数据也与当前各库相同。 2. 仅导出各数据库中的对象定义，包含表空间、库定义、函数定义、模式定义、表定义、索引定义和存储过程定义等。使用导出的对象定义，可以快速创建与当前主机相同的一个主机环境，拥有相同的数据库和表空间，但是库中并无原数据库的数据。 3. 仅导出数据。各库公共全局对象导出： 1. 仅导出表空间信息。 2. 仅导出角色信息。 3. 导出角色与表空间。	纯文本格式	纯文本格式数据文件导入使用 `gsql`工具

gs_dump 和 gs_dumpall 通过 -U 指定执行导出的用户帐户。如果当前使用的帐户不具备导出所要求的权限时，会无法导出数据。此时，需先将具有权限的角色赋权给无权限角色，然后在导出命令中设置 --role 参数来指定具备权限的角色。在执行命令后，gs_dump 和 gs_dumpall 会使用 --role 参数指定的角色，完成导出动作。

gs_dump 和 gs_dumpall 通过对导出的数据文件加密，导入时对加密的数据文件进行解密，可以防止数据信息泄露，为数据库的安全提供保证。注意，使用 gs_dump 加密的纯文本格式文件，如果导出的数据库中包含存储过程，因 gsql 不支持解密导入存储过程和函数，因此如果导出的数据库中包含存储过程/函数，请使用另外三种模式导出数据库，并使用 gs_restore 恢复。

gs_dump 和 gs_dumpall 工具在进行数据导出时，其他用户可以访问数据库（读或写）。

gs_dump 和 gs_dumpall 工具支持导出完整一致的数据。例如，T1 时刻启动 gs_dump 导出 A 数据库，或者启动 gs_dumpall 导出 openGauss 数据库，那么导出数据结果将会是 T1 时刻 A 数据库或者该 openGauss 数据库的数据状态，T1 时刻之后对 A 数据库或 openGauss 数据库的修改不会被导出。

禁止修改 -F c/d/t 格式导出的文件和内容，否则可能无法恢复成功。对于 -F p 格式导出的文件，如有需要，可根据需要谨慎编辑导出文件。

如果数据库中包含的对象数量（数据表、视图、索引）在 50 万以上，为了提高性能且避免出现内存问题，建议通过 gs_guc 工具设置数据库节点的如下参数（如果参数值大于如下建议值，则无需设置）。

gs_guc set -N all -I all -c 'max_prepared_transactions = 1000'
gs_guc set -N all -I all -c 'max_locks_per_transaction = 512'

若设置如上参数，则需重启数据库使参数生效。

 gs_om -t stop && gs_om -t start

为了保证数据一致性和完整性，导出工具会对需要转储的表设置共享锁。如果表在别的事务中设置了共享锁，gs_dump 和 gs_dumpall 会等待锁释放后锁定表。如果无法在指定时间内锁定某个表，转储会失败。用户可以通过指定 --lock-wait-timeout 选项，自定义等待锁超时时间。

由于 gs_dumpall 读取所有数据库中的表，因此必须以 openGauss 管理员身份进行连接，才能导出完整文件。在使用 gsql 执行脚本文件导入时，同样需要管理员权限，以便添加用户和组，以及创建数据库。

导出单个数据库

openGauss 支持使用 gs_dump 工具导出某个数据库级的内容，包含数据库的数据和所有对象定义。可根据需要自定义导出如下信息：

导出数据库全量信息，包含数据和所有对象定义。使用导出的全量信息可以创建一个与当前库相同的数据库，且库中数据也与当前库相同。
仅导出所有对象定义，包括：库定义、函数定义、模式定义、表定义、索引定义和存储过程定义等。使用导出的对象定义，可以快速创建一个相同的数据库，但是库中并无原数据库的数据。
仅导出数据，不包含所有对象定义。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_dump 导出指定数据库。

先创建一个数据库：

omm@postgres=# CREATE DATABASE stonedb WITH ENCODING 'UTF8';
CREATE DATABASE

omm@postgres=# \l
                          List of databases
   Name    | Owner | Encoding  | Collate | Ctype | Access privileges 
-----------+-------+-----------+---------+-------+-------------------
 postgres  | omm   | SQL_ASCII | C       | C     | =Tc/omm          +
           |       |           |         |       | omm=CTc/omm      +
           |       |           |         |       | stone=CTc/omm    +
           |       |           |         |       | stone=APm/omm
 stonedb   | omm   | UTF8      | C       | C     | 
 template0 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
 template1 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
(4 rows)

在新创建的数据库中创建用户及模式：

omm@postgres=# \c stonedb
Non-SSL connection (SSL connection is recommended when requiring high-security)
You are now connected to database "stonedb" as user "omm".

omm@stonedb=# CREATE USER hr IDENTIFIED BY 'Abcd1234';
CREATE ROLE

omm@stonedb=# \du hr
           List of roles
 Role name | Attributes | Member of 
-----------+------------+-----------
 hr        |            | {}

omm@stonedb=# \dn hr
List of schemas
 Name | Owner 
------+-------
 hr   | hr
(1 row)

使用新创建的用户在新创建的模式下创建表并插入数据：

omm@stonedb=# \c - hr
Password for user hr: 
Non-SSL connection (SSL connection is recommended when requiring high-security)
You are now connected to database "stonedb" as user "hr".

hr@stonedb=> CREATE TABLE emp(
   ID             INT        NOT NULL,
   NAME           char(8)    NOT NULL,
   AGE            INT,
   ADDRESS        CHAR(50),
   SALARY         REAL
);
CREATE TABLE

hr@stonedb=> INSERT INTO emp VALUES (1,'lily',28);
INSERT 0 1

hr@stonedb=> select * from emp;
 id |   name   | age | address | salary 
----+----------+-----+---------+--------
  1 | lily     |  28 |         |       
(1 row)

例子：导出 stonedb 数据库全量信息，导出文件格式为 SQL 文本格式

[omm@opengauss ~]$ gs_dump -F p -f backup/stonedb_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: Start dumping objects 
Progress: [==================================================] 100% (4833/4833, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:06:45]: total time: 367  ms

导入的 SQL 文本如下：

[omm@opengauss ~]$ cat backup/stonedb_backup.sql 
--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


--
-- Name: hr; Type: SCHEMA; Schema: -; Owner: hr
--

CREATE SCHEMA hr;


ALTER SCHEMA hr OWNER TO hr;

SET search_path = hr;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: emp; Type: TABLE; Schema: hr; Owner: hr; Tablespace: 
--

CREATE TABLE emp (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no, storage_type=ustore);


ALTER TABLE hr.emp OWNER TO hr;

--
-- Data for Name: emp; Type: TABLE DATA; Schema: hr; Owner: hr
--

COPY hr.emp (id, name, age, address, salary) FROM stdin;
1       lily            28      \N      \N
\.
;

--
-- Name: public; Type: ACL; Schema: -; Owner: omm
--

REVOKE ALL ON SCHEMA public FROM PUBLIC;
REVOKE ALL ON SCHEMA public FROM omm;
GRANT CREATE,USAGE ON SCHEMA public TO omm;
GRANT USAGE ON SCHEMA public TO PUBLIC;


--
-- openGauss database dump complete
--

例子：仅导出 stonedb 数据库中的数据，不包含数据库对象定义，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -a -F c -f backup/stonedb_data_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:20:07]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:20:08]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:08]: Start dumping objects 
Progress: [==================================================] 100% (4833/4833, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:08]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:08]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:20:08]: total time: 179  ms

例子：仅导出 stonedb 数据库所有对象的定义，导出文件格式为 SQL 文本格式

[omm@opengauss ~]$ gs_dump -s -F p -f backup/stonedb_def_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:20:40]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:20:40]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:41]: Start dumping objects 
Progress: [==================================================] 100% (4832/4832, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:41]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:20:41]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:20:41]: total time: 219  ms

导出的 SQL 文本如下：

[omm@opengauss ~]$ cat backup/stonedb_def_backup.sql 
--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


--
-- Name: hr; Type: SCHEMA; Schema: -; Owner: hr
--

CREATE SCHEMA hr;


ALTER SCHEMA hr OWNER TO hr;

SET search_path = hr;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: emp; Type: TABLE; Schema: hr; Owner: hr; Tablespace: 
--

CREATE TABLE emp (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no, storage_type=ustore);


ALTER TABLE hr.emp OWNER TO hr;

--
-- Name: public; Type: ACL; Schema: -; Owner: omm
--

REVOKE ALL ON SCHEMA public FROM PUBLIC;
REVOKE ALL ON SCHEMA public FROM omm;
GRANT CREATE,USAGE ON SCHEMA public TO omm;
GRANT USAGE ON SCHEMA public TO PUBLIC;


--
-- openGauss database dump complete
--

导出模式

openGauss 目前支持使用 gs_dump 工具导出模式级的内容，包含模式的数据和定义。用户可通过灵活的自定义方式导出模式内容，不仅支持选定一个模式或多个模式的导出，还支持排除一个模式或者多个模式的导出。可根据需要自定义导出如下信息：

导出模式全量信息，包含数据和对象定义。
仅导出数据，即模式包含表中的数据，不包含对象定义。
仅导出模式对象定义，包括：表定义、存储过程定义和索引定义等。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_dump 导出指定模式。

例子：导出 hr 模式全量信息，导出文件格式为文本格式

[omm@opengauss ~]$ gs_dump -n hr -F p -f backup/stonedb_hr_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: Start dumping objects 
Progress: [==================================================] 100% (4833/4833, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:36:45]: total time: 218  ms

导出的 SQL 文本如下：

[omm@opengauss ~]$ cat backup/stonedb_hr_backup.sql 
--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


--
-- Name: hr; Type: SCHEMA; Schema: -; Owner: hr
--

CREATE SCHEMA hr;


ALTER SCHEMA hr OWNER TO hr;

SET search_path = hr;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: emp; Type: TABLE; Schema: hr; Owner: hr; Tablespace: 
--

CREATE TABLE emp (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real
)
WITH (orientation=row, compression=no, storage_type=ustore);


ALTER TABLE hr.emp OWNER TO hr;

--
-- Data for Name: emp; Type: TABLE DATA; Schema: hr; Owner: hr
--

COPY hr.emp (id, name, age, address, salary) FROM stdin;
1       lily            28      \N      \N
\.
;

--
-- openGauss database dump complete
--

例子：仅导出 hr 模式的数据，导出文件格式为 TAR 归档格式

[omm@opengauss ~]$ gs_dump -n hr -a -F t -f backup/stonedb_hr_data_backup.tar stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: Start dumping objects 
Progress: [==================================================] 100% (4833/4833, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:42:52]: total time: 261  ms

例子：仅导出 hr 模式的定义，导出文件格式为目录归档格式

[omm@opengauss ~]$ gs_dump -n hr -s -F d -f backup/stonedb_hr_def_backup stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: Start dumping objects 
Progress: [==================================================] 100% (4832/4832, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:44:15]: total time: 202  ms

例子：导出 stonedb 数据库时，排除 hr 模式，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -N hr -F c -f backup/stonedb_ex_hr_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: Start dumping objects 
Progress: [==================================================] 100% (4831/4831, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:49:05]: total time: 183  ms

例子：同时导出 hr 和 public 模式，且仅导出模式定义，导出文件格式为 TAR 归档格式

[omm@opengauss ~]$ gs_dump -n hr -n public -s -F t -f backup/stonedb_hr_pub_def_backup.tar stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:53:35]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:53:36]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:53:36]: Start dumping objects 
Progress: [==================================================] 100% (4832/4832, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:53:36]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:53:36]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:53:36]: total time: 208  ms

例子：导出 stonedb 数据库时，排除 hr 和 public 模式，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -N hr -N public -F c -f backup/stonedb_ex_hr_pub_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:55:56]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:55:57]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:55:57]: Start dumping objects 
Progress: [==================================================] 100% (4831/4831, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:55:57]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:55:57]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:55:57]: total time: 254  ms

例子：导出 public 模式下所有表（视图、序列和外表）和 hr 模式中 emp 表，包含数据和表定义，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -t public.* -t hr.emp -F c -f backup/stonedb_pub_hr_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: no matching tables were found for pattern "public.*"
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: Start dumping objects 
Progress: [==================================================] 100% (3970/3970, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 11:59:12]: total time: 133  ms

导出表

openGauss 支持使用 gs_dump 工具导出表级的内容，包含表定义和表数据。视图、序列和外表属于特殊的表。用户可通过灵活的自定义方式导出表内容，不仅支持选定一个表或多个表的导出，还支持排除一个表或者多个表的导出。可根据需要自定义导出如下信息：

导出表全量信息，包含表数据和表定义。
仅导出数据，不包含表定义。
仅导出表定义。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_dump 导出指定表。

创建表及视图：

hr@stonedb=> CREATE TABLE department(
   ID             INT      PRIMARY KEY,
   NAME           CHAR(50) NOT NULL
);
NOTICE:  CREATE TABLE / PRIMARY KEY will create implicit index "department_pkey" for table "department"
CREATE TABLE

hr@stonedb=> INSERT INTO department VALUES(1,'IT');
INSERT 0 1

hr@stonedb=> CREATE TABLE employee(
   ID             INT        NOT NULL,
   NAME           char(8)    NOT NULL,
   AGE            INT,
   ADDRESS        CHAR(50),
   SALARY         REAL,
   DEPT_ID        INT references DEPARTMENT(ID)
);
CREATE TABLE

hr@stonedb=> INSERT INTO employee VALUES(1,'Lily',28,'','',1);
INSERT 0 1

hr@stonedb=> CREATE VIEW emp_vw AS SELECT e.id,e.name ename,e.age,e.address,e.salary,d.name dname FROM employee e,department d WHERE e.dept_id=d.id;
CREATE VIEW

hr@stonedb=> select * from emp_vw;
 id |  ename   | age | address | salary |                       dname                        
----+----------+-----+---------+--------+----------------------------------------------------
  1 | Lily     |  28 |         |        | IT                                                
(1 row)

例子：导出表 hr.employee 的定义和数据，导出文件格式为文本格式

[omm@opengauss ~]$ gs_dump -t hr.employee -F p -f backup/stonedb_hr_employee_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: Start dumping objects 
Progress: [==================================================] 100% (3977/3977, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 13:53:45]: total time: 221  ms

导入的 SQL 文本如下：

[omm@opengauss ~]$ cat backup/stonedb_hr_employee_backup.sql 
--
-- openGauss database dump
--

SET statement_timeout = 0;
SET xmloption = content;
SET client_encoding = 'UTF8';
SET standard_conforming_strings = on;
SET check_function_bodies = false;
SET session_replication_role = replica;
SET client_min_messages = warning;
SET enable_dump_trigger_definer = on;

--
-- Name: BEHAVIORCOMPAT; Type: BEHAVIORCOMPAT; Schema: -; Owner: 
--

SET behavior_compat_options = '';


SET search_path = hr;

SET default_tablespace = '';

SET default_with_oids = false;

--
-- Name: employee; Type: TABLE; Schema: hr; Owner: hr; Tablespace: 
--

CREATE TABLE employee (
    id integer NOT NULL,
    name character(8) NOT NULL,
    age integer,
    address character(50),
    salary real,
    dept_id integer
)
WITH (orientation=row, compression=no, storage_type=ustore);


ALTER TABLE hr.employee OWNER TO hr;

--
-- Data for Name: employee; Type: TABLE DATA; Schema: hr; Owner: hr
--

COPY hr.employee (id, name, age, address, salary, dept_id) FROM stdin;
1       Lily            28      \N      \N      1
\.
;

--
-- Name: employee_dept_id_fkey; Type: FK CONSTRAINT; Schema: hr; Owner: hr
--

ALTER TABLE employee
    ADD CONSTRAINT employee_dept_id_fkey FOREIGN KEY (dept_id) REFERENCES department(id);


--
-- openGauss database dump complete
--

例子：导出表 hr.employee 的定义，导出文件格式为目录归档格式

[omm@opengauss ~]$ gs_dump -t hr.employee -s -F d -f backup/stonedb_hr_employee_backup stonedb
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: Start dumping objects 
Progress: [==================================================] 100% (3976/3976, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 13:57:57]: total time: 177  ms

例子：不导出表 hr.employee，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -T hr.employee -F c -f backup/stonedb_ex_hr_employee_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: Start dumping objects 
Progress: [==================================================] 100% (4849/4849, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 13:59:40]: total time: 245  ms

例子：同时导出两个表 hr.employee 和 hr.department，导出文件格式为文本格式

[omm@opengauss ~]$ gs_dump -t hr.employee -t hr.department -F p -f backup/stonedb_hr_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: Start dumping objects 
Progress: [==================================================] 100% (4846/4846, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 14:01:57]: total time: 226  ms

例子：导出时排除两个表 hr.employee 和 hr.department，导出文件格式为文本格式

[omm@opengauss ~]$ gs_dump -T hr.employee -T hr.department -F p -f backup/stonedb_ex_hr_backup.sql stonedb
gs_dump[port='15400'][stonedb][2025-04-07 14:04:16]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 14:04:16]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 14:04:17]: Start dumping objects 
Progress: [==================================================] 100% (4846/4846, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:04:17]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:04:17]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 14:04:17]: total time: 227  ms

例子：导出表 hr.employee 的定义和数据，只导出表 hr.department 的定义，导出文件格式为 TAR 归档格式

[omm@opengauss ~]$ gs_dump -t hr.employee -t hr.department --exclude-table-data hr.department -F t -f backup/stonedb_hr_backup.tar stonedb
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: Start dumping objects 
Progress: [==================================================] 100% (4845/4845, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 14:07:37]: total time: 220  ms

例子：导出 public 模式下所有表（包括视图、序列和外表）和 hr 模式中 employee 表，包含数据和表定义，导出文件格式为自定义归档格式

[omm@opengauss ~]$ gs_dump -t public.* -t hr.employee -F c -f backup/stonedb_pub_hr_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: no matching tables were found for pattern "public.*"
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: Start dumping objects 
Progress: [==================================================] 100% (3977/3977, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 14:11:20]: total time: 217  ms

例子：仅导出依赖于 hr 模式下的 employee 表对象的视图信息，导出文件格式为目录归档格式

[omm@opengauss ~]$ gs_dump -t hr.employee --include-depend-objs --exclude-self -F d -f backup/stonedb_hr_backup stonedb
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: Start dumping objects 
Progress: [==================================================] 100% (4841/4841, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-07 14:14:18]: total time: 226  ms

导出所有数据库

openGauss 支持使用 gs_dumpall 工具导出所有数据库的全量信息，包含 openGauss 中每个数据库信息和公共的全局对象信息。可根据需要自定义导出如下信息：

导出所有数据库全量信息，包含 openGauss 中每个数据库信息和公共的全局对象信息（包含角色和表空间信息）。使用导出的全量信息可以创建与当前主机相同的一个主机环境，拥有相同数据库和公共全局对象，且库中数据也与当前各库相同。
仅导出数据，即导出每个数据库中的数据，且不包含所有对象定义和公共的全局对象信息。
仅导出所有对象定义，包括：表空间、库定义、函数定义、模式定义、表定义、索引定义和存储过程定义等。使用导出的对象定义，可以快速创建与当前主机相同的一个主机环境，拥有相同的数据库和表空间，但是库中并无原数据库的数据。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_dumpall 一次导出所有数据库信息。

例子：导出所有数据库全量信息，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -f backup/all_backup.sql
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: Finish scanning database. 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: Start dumping objects 
Progress: [==================================================] 100% (4892/4892, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: Finish dumping objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: dump database dbname='postgres' successfully
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:03:02]: total time: 447  ms
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:02]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:02]: Finish scanning database. 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:02]: Start dumping objects 
Progress: [==================================================] 100% (4851/4851, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:02]: Finish dumping objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:03]: dump database dbname='stonedb' successfully
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:03:03]: total time: 341  ms
gs_dumpall[port='15400'][2025-04-07 15:03:03]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:03:03]: total time: 925  ms

例子：仅导出所有数据库定义，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -s -f backup/all_def_backup.sql
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:07]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:08]: Finish scanning database. 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:08]: Start dumping objects 
Progress: [==================================================] 100% (4880/4880, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:08]: Finish dumping objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:08]: dump database dbname='postgres' successfully
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:06:08]: total time: 308  ms
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: Finish scanning database. 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: Start dumping objects 
Progress: [==================================================] 100% (4848/4848, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: Finish dumping objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: dump database dbname='stonedb' successfully
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:06:08]: total time: 310  ms
gs_dumpall[port='15400'][2025-04-07 15:06:08]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:06:08]: total time: 709  ms

例子：仅导出所有数据库中数据，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -a -f backup/all_data_backup.sql
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: Finish scanning database. 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: Start dumping objects 
Progress: [==================================================] 100% (4892/4892, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: Finish dumping objects 
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: dump database dbname='postgres' successfully
gs_dump[port='15400'][dbname='postgres'][2025-04-07 15:07:37]: total time: 268  ms
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: Finish scanning database. 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: Start dumping objects 
Progress: [==================================================] 100% (4851/4851, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: Finish dumping objects 
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: dump database dbname='stonedb' successfully
gs_dump[port='15400'][dbname='stonedb'][2025-04-07 15:07:37]: total time: 211  ms
gs_dumpall[port='15400'][2025-04-07 15:07:37]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:07:37]: total time: 560  ms

导出全局对象

openGauss 支持使用 gs_dumpall 工具导出所有数据库公共的全局对象，包含数据库用户和组、表空间及属性（例如：适用于数据库整体的访问权限）信息。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_dumpall 导出表空间对象信息。

例子：导出所有数据库的公共全局表空间信息和用户信息，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -g -f backup/globals.sql
gs_dumpall[port='15400'][2025-04-07 15:18:20]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:18:20]: total time: 47  ms

例子：导出所有数据库的公共全局表空间信息，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -t -f backup/tablespace.sql
gs_dumpall[port='15400'][2025-04-07 15:21:14]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:21:14]: total time: 40  ms

例子：导出所有数据库的公共全局用户信息，导出文件为文本格式

[omm@opengauss ~]$ gs_dumpall -r -f backup/user.sql
gs_dumpall[port='15400'][2025-04-07 15:22:18]: dumpall operation successful
gs_dumpall[port='15400'][2025-04-07 15:22:18]: total time: 44  ms

导入数据

openGauss 数据库提供了灵活的数据入库方式：INSERT、COPY 以及 gsql 元命令 \copy。各方式的特点如下：

方式	特点
INSERT	通过 INSERT 语句插入一行或多行数据，及从指定表插入数据。
COPY	通过 COPY FROM STDIN 语句直接向 openGauss 数据库写入数据。通过 JDBC 驱动的 CopyManager 接口从其他数据库向 openGauss 数据库写入数据时，具有业务数据无需落地成文件的优势。
`gsql` 工具的元命令 `\copy`	与直接使用 SQL 语句 COPY 不同，该命令读取/写入的文件只能是 `gsql` 客户端所在机器上的本地文件。说明： `\COPY` 只适合小批量、格式良好的数据导入，不会对非法字符做预处理，也无容错能力，无法适用于含有异常数据的场景。导入数据应优先选择 COPY。

COPY

功能描述：

通过 COPY 命令实现在表和文件之间拷贝数据。
COPY FROM：从一个文件拷贝数据到一个表。
COPY TO：把一个表的数据拷贝到一个文件。

注意事项：

当参数 enable_copy_server_files 关闭时，只允许初始用户执行 COPY FROM FILENAME 或 COPY TO FILENAME 命令，当参数 enable_copy_server_files 打开，允许具有 SYSADMIN 权限的用户或继承了内置角色 gs_role_copy_files 权限的用户执行，但默认禁止对数据库配置文件、密钥文件、证书文件和审计日志执行 COPY FROM FILENAME 或 COPY TO FILENAME，以防止用户越权查看或修改敏感文件。
COPY 只能用于表，不能用于视图。
COPY TO 需要读取的表的 SELECT 权限，COPY FROM 需要插入的表的 INSERT 权限。
如果声明了一个字段列表，COPY 将只在文件和表之间拷贝已声明字段的数据。如果表中有任何不在字段列表里的字段，COPY FROM 将为那些字段插入缺省值。
如果声明了数据源文件，服务器必须可以访问该文件；如果指定了 STDIN，数据将在客户前端和服务器之间流动，输入时，表的列与列之间使用 TAB 键分隔，在新的一行中以反斜杠和句点（\.）表示输入结束。
如果数据文件的任意行包含比预期多或者少的字段，COPY FROM 将抛出一个错误。
数据的结束可以用一个只包含反斜杠和句点（\.）的行表示。如果从文件中读取数据，数据结束的标记是不必要的；如果在客户端应用之间拷贝数据，必须要有结束标记。
COPY FROM 中 \N 为空字符串，如果要输入实际数据值 \N ，使用 \\N。
COPY FROM 不支持在导入过程中对数据做预处理（比如说表达式运算、填充指定默认值等）。如果需要在导入过程中对数据做预处理，用户需先把数据导入到临时表中，然后执行 SQL 语句通过运算插入到表中，但此方法会导致 I/O 膨胀，降低导入性能。
COPY FROM 在遇到数据格式错误时会回滚事务，但没有足够的错误信息，不方便用户从大量的原始数据中定位错误数据。
COPY FROM/TO 适合低并发，本地小数据量导入导出。
目标表存在触发器，支持 COPY 操作。
COPY 命令中，生成列不能出现在指定列的列表中。使用 COPY TO 导出数据时，如果没有指定列的列表，则该表的所有列除了生成列都会被导出。COPY FROM 导入数据时，生成列会自动更新，并像普通列一样保存。

语法：

从一个文件复制数据到一个表

  COPY table_name [ ( column_name [, ...] ) ]
  FROM { 'filename' | STDIN }
  [ [ USING ] DELIMITERS 'delimiters' ]
  [ WITHOUT ESCAPING ]
  [ LOG ERRORS ]
  [ LOG ERRORS DATA ]
  [ REJECT LIMIT 'limit' ]
  [ [ WITH ]
      ( option [, ...] )
      | ( copy_option [, ...] )
      | [ TRANSFORM ( { column_name [ data_type ] [ AS transform_expr ] } [, ...] ) ]
      | [ FIXED FORMATTER ( { column_name( offset, length ) } [, ...] ) ]
  ]

说明：
上述语法中 FIXED FORMATTER 与 copy_option 语法兼容、与 option 语法不兼容；copy_option 与 option 语法不兼容；TRANSFORM 与 copy_option、FIXED FORMATTER 语法兼容。

把一个表的数据拷贝到一个文件

COPY table_name [ ( column_name [, ...] ) ]
    TO { 'filename' | STDOUT }
    [ [ USING ] DELIMITERS 'delimiters' ]
    [ WITHOUT ESCAPING ]
    [ [ WITH ] ( option [, ...] ) ]
    | copy_option
    | [ FIXED FORMATTER ( { column_name( offset, length ) } [, ...] ) ];

COPY query
    TO { 'filename' | STDOUT }
    [ WITHOUT ESCAPING ]
    [ [ WITH ] ( option [, ...] ) ]
    | copy_option
    | [ FIXED FORMATTER ( { column_name( offset, length ) } [, ...] ) ];

说明：
COPY TO 语法形式约束如下： query 与 [USING] DELIMITER 不兼容，即若 COPY TO 的数据来自于一个 query 的查询结果，那么 COPY TO 语法不能再指定 [USING] DELIMITERS 语法子句。
对于 FIXED FORMATTTER 语法后面跟随的 copy_option 是以空格进行分隔的。
copy_option 是指 COPY 原生的参数形式，而 option 是兼容外表导入的参数形式。
语法中的 FIXED FORMATTER ( { column_name( offset, length ) } [, …] ) 以及 [ ( option [, …] ) | copy_option [ …] ] 可以任意排列组合。

其中可选参数 option 子句语法为：

FORMAT format_name
| OIDS [ boolean ]
| DELIMITER 'delimiter_character'
| NULL 'null_string'
| HEADER [ boolean ]
| FILEHEADER 'header_file_string'
| FREEZE [ boolean ]
| QUOTE 'quote_character'
| ESCAPE 'escape_character'
| EOL 'newline_character'
| NOESCAPING [ boolean ]
| FORCE_QUOTE { ( column_name [, ...] ) | * }
| FORCE_NOT_NULL ( column_name [, ...] )
| ENCODING 'encoding_name'
| IGNORE_EXTRA_DATA [ boolean ]
| FILL_MISSING_FIELDS [ boolean ]
| COMPATIBLE_ILLEGAL_CHARS [ boolean ]
| DATE_FORMAT 'date_format_string'
| TIME_FORMAT 'time_format_string'
| TIMESTAMP_FORMAT 'timestamp_format_string'
| SMALLDATETIME_FORMAT 'smalldatetime_format_string'

其中可选参数 copy_option 子句语法为：

OIDS
| NULL 'null_string'
| HEADER
| FILEHEADER 'header_file_string'
| FREEZE
| FORCE NOT NULL column_name [, ...]
| FORCE QUOTE { column_name [, ...] | * }
| BINARY
| CSV
| QUOTE [ AS ] 'quote_character'
| ESCAPE [ AS ] 'escape_character'
| EOL 'newline_character'
| ENCODING 'encoding_name'
| IGNORE_EXTRA_DATA
| FILL_MISSING_FIELDS
| COMPATIBLE_ILLEGAL_CHARS
| DATE_FORMAT 'date_format_string'
| TIME_FORMAT 'time_format_string'
| TIMESTAMP_FORMAT 'timestamp_format_string'
| SMALLDATETIME_FORMAT 'smalldatetime_format_string'

参数说明：

query：其结果将被拷贝。取值范围：一个必须用圆括号包围的 SELECT 或 VALUES 命令。
table_name：表的名称（可以有模式修饰）。取值范围：已存在的表名。
column_name：可选的待拷贝字段列表。取值范围：如果没有声明字段列表，将使用所有字段。
STDIN：声明输入是来自标准输入。
STDOUT：声明输出打印到标准输出。
FIXED：打开字段固定长度模式。在字段固定长度模式下，不能声明 DELIMITER、NULL、CSV 选项。指定 FIXED 类型后，不能再通过 option 或 copy_option 指定 BINARY、CSV、TEXT 等类型。
[USING] DELIMITER 'delimiters'：在文件中分隔各个字段的字符串，分隔符最大长度不超过 10 个字节。取值范围：不允许包含 .abcdefghijklmnopqrstuvwxyz0123456789 中的任何一个字符。缺省值：在文本模式下，缺省是水平制表符，在 CSV 模式下是一个逗号。
WITHOUT ESCAPING：在 TEXT 格式中，不对 \ 和后面的字符进行转义。取值范围：仅支持 TEXT 格式。
LOG ERRORS：若指定，则开启对于 COPY FROM 语句中数据类型错误的容错机制。取值范围：仅支持导入（即 COPY FROM ）时指定。
LOG ERRORS DATA：LOG ERRORS DATA 和 LOG ERRORS 的区别：
- LOG ERRORS DATA 会填充容错表的 rawrecord 字段。
- 只有 supper 权限的用户才能使用 LOG ERRORS DATA 参数选项。
REJECT LIMIT 'imit'：与 LOG ERROR 选项共同使用，对 COPY FROM 的容错机制设置数值上限，一旦此 COPY FROM 语句错误数据超过选项指定条数，则会按照原有机制报错。
- 取值范围：正整数（1-INTMAX），unlimited（无最大值限制）
- 缺省值：若未指定 LOG ERRORS，则会报错；若指定 LOG ERRORS，则默认为 0。
FORMATTER：在固定长度模式中，定义每一个字段在数据文件中的位置。按照 column(offset,length) 格式定义每一列在数据文件中的位置。取值范围：
- offset 取值不能小于 0，以字节为单位。
- length 取值不能小于 0，以字节为单位。
- 所有列的总长度和不能大于 1GB。
- 文件中没有出现的列默认以空值代替。
OPTION { option_name ' value ' }：用于指定兼容外表的各类参数。
- FORMAT：数据源文件的格式。取值范围：CSV、TEXT、FIXED、BINARY。
  - CSV 格式的文件，可以有效处理数据列中的换行符，但对一些特殊字符处理有欠缺。
  - TEXT 格式的文件，可以有效处理一些特殊字符，但无法正确处理数据列中的换行符。
  - FIXED 格式的文件，适用于每条数据的数据列都比较固定的数据，长度不足的列会添加空格补齐，过长的列则会自动截断。
  - BINARY 形式的选项会使得所有的数据被存储/读作二进制格式而不是文本。这比 TEXT 和 CSV 格式的要快一些，但是一个 BINARY 格式文件可移植性比较差。
  - 缺省值：TEXT
- DELIMITER：指定数据文件行数据的字段分隔符。
  - 取值范围：支持多字符分隔符，但分隔符不能超过 10 个字节。不能是 \r 和 \n。
  - TEXT 格式的默认分隔符是水平制表符（TAB）。
  - CSV 格式的默认分隔符为 ,。
  - FIXED 格式没有分隔符。
- NULL：用来指定数据文件中空值的表示。
  - CSV 格式下默认值是一个没有引号的空字符串。
  - TEXT 格式下默认值是 \N。
- HEADER：指定导出数据文件是否包含标题行，标题行一般用来描述表中每个字段的信息。HEADER 只能用于 CSV、FIXED 格式的文件中。在导入数据时，如果 HEADER 选项为 on，则数据文本第一行会被识别为标题行，会忽略此行。如果 HEADER 为 off，而数据文件中第一行会被识别为数据。在导出数据时，如果 HEADER 选项为 on，且未指定 FILEHEADER，则将把表的列名信息导出到文件的第一行；如果指定了 FILEHEADER，则将把 FILEHEADER 文件的第一行导出到最终输出文件的第一行。如果 HEADER 为 off，则导出数据文件不包含标题行。
  - 取值范围：true/on、false/off。
  - 缺省值：false
- QUOTE：CSV 格式文件下的引号字符。缺省值：双引号。
- ESCAPE：CSV 格式下，用来指定逃逸字符，逃逸字符只能指定为单字节字符。缺省值：双引号。当与 QUOTE 值相同时，会被替换为 \0。
- EOL 'newline_character'：指定导入导出数据文件换行符样式。
  - 取值范围：支持多字符换行符，但换行符不能超过 10 个字节。常见的换行符，如 \r、\n、\r\n（设成 0x0D、0x0A、0x0D0A 效果是相同的），其他字符或字符串，如 $、#。
  - EOL 参数只能用于 TEXT 格式的导入导出，不支持 CSV 格式和 FIXED 格式导入。为了兼容原有 EOL 参数，仍然支持导出 CSV 格式和 FIXED 格式时指定 EOL 参数为 0x0D 或 0x0D0A。
  - EOL 参数不能和分隔符、NULL 参数相同。
  - EOL 参数不能包含：.abcdefghijklmnopqrstuvwxyz0123456789。
- FORCE_QUOTE { ( column_name [, …] ) | * }：在 CSV COPY TO 模式下，强制在每个声明的字段周围对所有非 NULL 值都使用引号包围。NULL 输出不会被引号包围。取值范围：已存在的字段。
- FORCE_NOT_NULL ( column_name [, …] )：此函数指定的列将不会把输入匹配（识别）为 NULL 字符串。NULL 值字符串将被默认为空字符串，即长度为零的字符串而不是 NULL，即使它们没有用引号引起来。此选项仅允许在 COPY FROM 语句中，并且仅在指定为 CSV 格式时被允许使用。取值范围：已存在的字段。
- ENCODING：指定数据文件的编码格式名称，缺省为当前数据库编码格式。
- IGNORE_EXTRA_DATA：若数据源文件比外表定义列数多，是否会忽略多出的列。该参数只在数据导入过程中使用。
  - 取值范围：true/on、false/off。
  - 参数为 true/on，若数据源文件比外表定义列数多，则忽略行尾多出来的列。
  - 参数为 false/off，若数据源文件比外表定义列数多，会显示如下错误信息。
```
extra data after last expected column
```
  - 缺省值：false。
- COMPATIBLE_ILLEGAL_CHARS：导入非法字符容错参数。此语法仅对 COPY FROM 导入有效。
  - 取值范围：true/on、false/off。
  - 参数为 true/on，则导入时遇到非法字符进行容错处理，非法字符转换后入库，不报错，不中断导入。
  - 参数为 false/off，导入时遇到非法字符进行报错，中断导入。
  - 缺省值： false/off。
- FILL_MISSING_FIELDS：当数据加载时，若数据源文件中一行的最后一个字段缺失的处理方式。
  - 取值范围：true/on、false/off。
  - 缺省值： false/off。
- DATE_FORMAT：导入对于 DATE 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。
- TIME_FORMAT：导入对于 TIME 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。取值范围：合法 TIME 格式，不支持时区。
- TIMESTAMP_FORMAT：导入对于 TIMESTAMP 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。取值范围：合法 TIMESTAMP 格式，不支持时区。
- SMALLDATETIME_FORMAT：导入对于 SMALLDATETIME 类型指定格式。此参数不支持 BINARY 格式，会报cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。
COPY_OPTION { option_name ' value ' }：用于指定 COPY 原生的各类参数。
- NULL：用来指定数据文件中空值的表示。
  - CSV 格式下默认值是一个没有引号的空字符串。
  - TEXT 格式下默认值是 \N。
- HEADER：指定导出数据文件是否包含标题行，标题行一般用来描述表中每个字段的信息。HEADER 只能用于 CSV、FIXED 格式的文件中。在导入数据时，如果 HEADER 选项为 on，则数据文本第一行会被识别为标题行，会忽略此行。如果 HEADER 为 off，而数据文件中第一行会被识别为数据。在导出数据时，如果 HEADER 选项为 on，且未指定 FILEHEADER，则将把表的列名信息导出到文件的第一行；如果指定了 FILEHEADER，则将把 FILEHEADER 文件的第一行导出到最终输出文件的第一行。如果 HEADER 为 off，则导出数据文件不包含标题行。
  - 取值范围：true/on、false/off。
  - 缺省值：false
- FILEHEADER：导出数据时用于定义标题行的文件，一般用来描述每一列的数据信息。
  - 仅在 HEADER 为 on 或 true 的情况下有效。
  - FILEHEADER 指定的是绝对路径。
  - 该文件只能包含一行标题信息，并以换行符结尾，多余的行将被丢弃（标题信息不能包含换行符）。
  - 该文件包括换行符在内长度不超过 1M。
- FREEZE：将 COPY 加载的数据行设置为已经被 FROZEN，就像这些数据行执行过 VACUUM FREEZE。这是一个初始数据加载的性能选项。仅当以下三个条件同时满足时，数据行会被 FROZEN：
  - 在同一事务中 CREATE 或 TRUNCATE 这张表之后执行 COPY。
  - 当前事务中没有打开的游标。
  - 当前事务中没有原有的快照。
- FORCE NOT NULL column_name [, …]：在 CSV COPY FROM 模式下，指定的字段不为空。若输入为空，则将视为长度为 0 的字符串。取值范围：已存在的字段。
- FORCE NULL column_name [, …]：在 CSV COPY FROM 模式下，将指定的字段表示空值的字符串设置为 NULL，包括加了引号的空值字符串。取值范围：已存在的字段。
- FORCE QUOTE { column_name [, …] | * }：在 CSV COPY TO 模式下，强制在每个声明的字段周围对所有非 NULL 值都使用引号包围。NULL 输出不会被引号包围。取值范围：已存在的字段。
- BINARY：使用二进制格式存储和读取，而不是以文本的方式。在二进制模式下，不能声明 DELIMITER、NULL、CSV 选项。指定 BINARY 类型后，不能再通过 option 或 copy_option 指定 CSV、FIXED、TEXT 等类型。
- CSV：打开逗号分隔变量（CSV）模式。指定 CSV 类型后，不能再通过 option 或 copy_option 指定 BINARY、FIXED、TEXT 等类型。
- QUOTE [AS] 'quote_character'：CSV 格式文件下的引号字符。缺省值：双引号。
- ESCAPE：CSV 格式下，用来指定逃逸字符，逃逸字符只能指定为单字节字符。缺省值：双引号。当与 QUOTE 值相同时，会被替换为 \0。
- EOL 'newline_character'：指定导入导出数据文件换行符样式。
  - 取值范围：支持多字符换行符，但换行符不能超过 10 个字节。常见的换行符，如 \r、\n、\r\n（设成 0x0D、0x0A、0x0D0A 效果是相同的），其他字符或字符串，如 $、#。
  - EOL 参数只能用于 TEXT 格式的导入导出，不支持 CSV 格式和 FIXED 格式导入。为了兼容原有 EOL 参数，仍然支持导出 CSV 格式和 FIXED 格式时指定 EOL 参数为 0x0D 或 0x0D0A。
  - EOL 参数不能和分隔符、NULL 参数相同。
  - EOL 参数不能包含：.abcdefghijklmnopqrstuvwxyz0123456789。
- ENCODING：指定数据文件的编码格式名称，缺省为当前数据库编码格式。
- IGNORE_EXTRA_DATA：指定当数据源文件比外表定义列数多时，忽略行尾多出来的列。该参数只在数据导入过程中使用。若不使用该参数，在数据源文件比外表定义列数多，会显示如下错误信息。
```
extra data after last expected column
```
- COMPATIBLE_ILLEGAL_CHARS：指定导入时对非法字符进行容错处理，非法字符转换后入库。不报错，不中断导入。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。若不使用该参数，导入时遇到非法字符进行报错，中断导入。
- FILL_MISSING_FIELDS：当数据加载时，若数据源文件中一行的最后一个字段缺失的处理方式。
  - 取值范围：true/on、false/off。
  - 缺省值： false/off。
- DATE_FORMAT：导入对于 DATE 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。
- TIME_FORMAT：导入对于 TIME 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。取值范围：合法 TIME 格式，不支持时区。
- TIMESTAMP_FORMAT：导入对于 TIMESTAMP 类型指定格式。此参数不支持 BINARY 格式，会报 cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。取值范围：合法 TIMESTAMP 格式，不支持时区。
- SMALLDATETIME_FORMAT：导入对于 SMALLDATETIME 类型指定格式。此参数不支持 BINARY 格式，会报cannot specify bulkload compatibility options in BINARY mode 错误信息。此参数仅对 COPY FROM 导入有效。取值范围：合法 SMALLDATETIME 格式。
- TRANSFORM ( { column_name [ data_type ] [ AS transform_expr ] } [, …] )：指定表中各个列的转换表达式；其中 data_type 指定该列在表达式参数中的数据类型；transform_expr 为目标表达式，返回与表中目标列数据类型一致的结果值。
COPY FROM 能够识别的特殊反斜杠序列如下所示：
- \b：反斜杠（ASCII 8）
- \f：换页（ASCII 12）
- \n：换行符（ASCII 10）
- \r：回车符（ASCII 13）
- \t：水平制表符（ASCII 9）
- \v：垂直制表符（ASCII 11）
- \digits：反斜杠后面跟着一到三个八进制数，表示 ASCII 值为该数的字符。
- \xdigits：反斜杠 x 后面跟着一个或两个十六进制位声明指定数值编码的字符。

例子：拷贝表数据到 CSV 文件中

omm@stonedb=# COPY hr.emp TO '/home/omm/backup/emp.csv' WITH CSV;
COPY 1

结果如下：

[omm@opengauss ~]$ cat backup/emp.csv 
1,lily    ,28,,

例子：拷贝 CSV 文件数据到表中

CSV 文件数据如下：

[omm@opengauss ~]$ cat data/emp.csv 
员工编号,姓名,年龄,地址,工资
1,张三,30,北京朝阳,5000
2,李四,28,上海浦东,6000
3,王五,35,广州天河,7000
4,赵六,40,深圳南山,8000
5,陈七,25,杭州西湖,5500

拷贝数据到表中：

omm@stonedb=# COPY hr.emp FROM '/home/omm/data/emp.csv' WITH CSV HEADER;
COPY 5

omm@stonedb=# select * from hr.emp;
 id |  name  | age |                    address                     | salary 
----+--------+-----+------------------------------------------------+--------
  1 | 张三   |  30 | 北京朝阳                                       |   5000
  2 | 李四   |  28 | 上海浦东                                       |   6000
  3 | 王五   |  35 | 广州天河                                       |   7000
  4 | 赵六   |  40 | 深圳南山                                       |   8000
  5 | 陈七   |  25 | 杭州西湖                                       |   5500
(5 rows)

元命令导入数据

gsql 工具提供了元命令 \copy 进行数据导入。

在任何 gsql 客户端登录数据库成功后，可以使用该命令进行数据的导入/导出。但是与 SQL 的 COPY 命令不同，该命令读取/写入的文件是本地文件，而非数据库服务器端文件；所以，要操作的文件的可访问性、权限等，都是受限于本地用户的权限。

说明：

\copy 只适合小批量、格式良好的数据导入，不会对非法字符做预处理，也无容错能力，无法适用于含有异常数据的场景。导入数据应优先选择 COPY。
\copy 可以指定数据导入时的客户端数量，从而实现数据文件的并行导入，目前并发数范围为 [1, 8]。
\copy 并行导入目前存在以下约束：临时表的并行导入不支持、在事务内的并行导入不支持、对二进制文件的并行导入不支持、数据导入支持 AES128 加密时不支持以及 COPY 选项中存在 EOL。在这些情况下，即使指定了 parallel 参数，仍然会走非并行流程。
\copy 支持并行导入 INTERVAL 分区表，但受自治事务并发参数影响，如 max_concurrent_autonomous_transactions 为 0，或自治事务并发数已全部占满时，根据插入数据量和分区数可能会执行成功或发生锁等待卡住。

语法：

\copy { table [ ( column_list ) ] |
( query ) } { from | to } { filename |
stdin | stdout | pstdin | pstdout }
[parallel integer] [ with ] [ binary ] [ delimiter
[ as ] 'character' ] [without escaping] [ null [ as ] 'string' ]
[ csv [ header ] [ quote [ as ]
'character' ] [ escape [ as ] 'character' ]
[ force quote column_list | * ] [ force
not null column_list ] ]
[compatible _illegal_chars]

其参数含义参考上一节的 COPY 语句。

例子：从标准输入拷贝数据到表中

omm@postgres=# \c stonedb hr   
Password for user hr: 
Non-SSL connection (SSL connection is recommended when requiring high-security)
You are now connected to database "stonedb" as user "hr".

hr@stonedb=> CREATE TABLE a(a int);
CREATE TABLE

hr@stonedb=> \copy a from stdin;
Enter data to be copied followed by a newline.
End with a backslash and a period on a line by itself.
>> 1
>> 2
>> \.

hr@stonedb=> select * from a;
 a 
---
 1
 2
(2 rows)

例子：从 CSV 文件中拷贝数据到表中

hr@stonedb=> truncate table emp;
TRUNCATE TABLE
hr@stonedb=> \copy emp FROM '/home/omm/data/emp.csv' WITH CSV HEADER;

hr@stonedb=> select * from emp;
 id |  name  | age |                    address                     | salary 
----+--------+-----+------------------------------------------------+--------
  1 | 张三   |  30 | 北京朝阳                                       |   5000
  2 | 李四   |  28 | 上海浦东                                       |   6000
  3 | 王五   |  35 | 广州天河                                       |   7000
  4 | 赵六   |  40 | 深圳南山                                       |   8000
  5 | 陈七   |  25 | 杭州西湖                                       |   5500
(5 rows)

例子：将表数据拷贝到文件中

hr@stonedb=> \copy emp TO '/home/omm/backup/emp.csv' WITH CSV;

结果如下：

[omm@opengauss ~]$ cat backup/emp.csv 
1,张三  ,30,北京朝阳                                      ,5000
2,李四  ,28,上海浦东                                      ,6000
3,王五  ,35,广州天河                                      ,7000
4,赵六  ,40,深圳南山                                      ,8000
5,陈七  ,25,杭州西湖                                      ,5500

gs_restore 命令导入数据

gs_restore 是 openGauss 数据库提供的与 gs_dump 配套的导入工具。通过该工具，可将 gs_dump 导出的文件导入至数据库。gs_restore 支持导入的文件格式包含自定义归档格式、目录归档格式和 TAR 归档格式。

gs_restore 具备如下两种功能。

导入至数据库：如果指定了数据库，则数据将被导入到指定的数据库中。其中，并行导入必须指定连接数据库的密码。导入时生成列会自动更新，并像普通列一样保存。
导入至脚本文件：如果未指定导入数据库，则创建包含重建数据库所需的 SQL 语句脚本，并将其写入至文件或者标准输出。该脚本文件等效于 gs_dump 导出的纯文本格式文件。

gs_restore 工具在导入时，允许用户选择需要导入的内容，并支持在数据导入前对等待导入的内容进行排序。

gs_restore 默认是以追加的方式进行数据导入。为避免多次导入造成数据异常，在进行导入时，建议选择使用 -c 和 -e 参数。-c 表示在重新创建数据库对象前，清理（删除）已存在于将要还原的数据库中的数据库对象；-e 表示当发送 SQL 语句到数据库时如果出现错误请退出，默认状态下会继续，且在导入后会显示一系列错误信息。

操作步骤：

以操作系统用户 omm 登录数据库主节点。
使用 gs_restore 命令导入数据。

常用参数：

参数	参数说明
`-d`	连接的数据库，并直接将数据导入到该数据库中。
`-e`	当发送 SQL 语句到数据库时如果出现错误，则退出。默认状态下会忽略错误任务并继续执行导入，且在导入后会显示一系列错误信息。
`-c`	在重新创建数据库对象前，清理（删除）已存在于将要导入的数据库中的数据库对象。
`-s`	只导入模式定义，不导入数据。当前的序列值也不会被导入。

其他参数参考：gs_restoreopen in new window

先创建一个数据库：

omm@postgres=# CREATE DATABASE backupdb WITH ENCODING 'UTF8';
CREATE DATABASE

omm@postgres=# \l
                          List of databases
   Name    | Owner | Encoding  | Collate | Ctype | Access privileges 
-----------+-------+-----------+---------+-------+-------------------
 backupdb  | omm   | UTF8      | C       | C     | 
 postgres  | omm   | SQL_ASCII | C       | C     | =Tc/omm          +
           |       |           |         |       | omm=CTc/omm      +
           |       |           |         |       | stone=CTc/omm    +
           |       |           |         |       | stone=APm/omm
 stonedb   | omm   | UTF8      | C       | C     | 
 template0 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
 template1 | omm   | SQL_ASCII | C       | C     | =c/omm           +
           |       |           |         |       | omm=CTc/omm
(5 rows)

例子：导出 stonedb 到 DMP 文件然后导入到 backupdb 数据库

[omm@opengauss ~]$ gs_dump -F c -f backup/stonedb_backup.dmp stonedb
gs_dump[port='15400'][stonedb][2025-04-08 16:24:44]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-08 16:24:45]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-08 16:24:45]: Start dumping objects 
Progress: [==================================================] 100% (4856/4856, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:24:45]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:24:45]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-08 16:24:45]: total time: 554  ms

[omm@opengauss ~]$ gs_restore -d backupdb backup/stonedb_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 79  ms

例子：导出 stonedb 到 TAR 文件然后导入到 backupdb 数据库

[omm@opengauss ~]$ gs_dump -F t -f backup/stonedb_backup.tar stonedb
gs_dump[port='15400'][stonedb][2025-04-08 16:28:00]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-08 16:28:01]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-08 16:28:01]: Start dumping objects 
Progress: [==================================================] 100% (4856/4856, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:28:01]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:28:01]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-08 16:28:01]: total time: 257  ms

[omm@opengauss ~]$ gs_restore -e -c -d backupdb backup/stonedb_backup.tar
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 60  ms

例子：导出 stonedb 到目录文件然后导入到 backupdb 数据库

[omm@opengauss ~]$ gs_dump -F d -f backup/stonedb_backup stonedb
gs_dump[port='15400'][stonedb][2025-04-08 16:39:37]: Begin scanning database. 
Progress: [==================================================] 100% (38/37, cur_step/total_step). finish scanning database                       
gs_dump[port='15400'][stonedb][2025-04-08 16:39:38]: Finish scanning database. 
gs_dump[port='15400'][stonedb][2025-04-08 16:39:38]: Start dumping objects 
Progress: [==================================================] 100% (4827/4827, dumpObjNums/totalObjNums). dump objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:39:38]: Finish dumping objects 
gs_dump[port='15400'][stonedb][2025-04-08 16:39:38]: dump database stonedb successfully
gs_dump[port='15400'][stonedb][2025-04-08 16:39:38]: total time: 194  ms

[omm@opengauss ~]$ gs_restore -e -c -d backupdb backup/stonedb_backup
start restore operation ...
Progress: [==================================================] 100% (5/5, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 17  ms

例子：将 stonedb 数据库的所有对象的定义导入至 backupdb 数据库。导入前，数据库存在完整的定义和数据，导入后， backupdb 数据库只存在所有对象定义，表没有数据

[omm@opengauss ~]$ gs_restore -s -e -c -d backupdb backup/stonedb_backup.tar
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 57  ms

例子：导入 DMP 文件中 hr 模式的所有定义和数据。在导入时会先删除已经存在的对象，如果原对象存在跨模式的依赖则需手工强制干预

[omm@opengauss ~]$ gs_restore -e -c -n hr -d backupdb backup/stonedb_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 65  ms

例子：导入 DMP 文件中 hr 模式下表 hr.emp 的定义。在导入之前，hr.emp 表不存在，需要确保存在 hr 这个模式

omm@backupdb=# drop table hr.emp;
DROP TABLE

[omm@opengauss ~]$ gs_restore -s -e -c -n hr -t emp -d backupdb backup/stonedb_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 19  ms

omm@backupdb=# \dt hr.emp;
                                  List of relations
 Schema | Name | Type  | Owner |                       Storage                        
--------+------+-------+-------+------------------------------------------------------
 hr     | emp  | table | hr    | {orientation=row,compression=no,storage_type=ustore}
(1 row)

例子：导入 DMP 文件中 hr 模式下表 hr.emp 的数据。在导入之前，hr.emp 表不存在数据，需要确保存在 hr 这个模式

omm@backupdb=# select * from hr.emp;
 id | name | age | address | salary 
----+------+-----+---------+--------
(0 rows)

[omm@opengauss ~]$ gs_restore -a -e -n hr -t emp -d backupdb backup/stonedb_backup.dmp
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 18  ms

omm@backupdb=# select * from hr.emp;
 id |  name  | age |                    address                     | salary 
----+--------+-----+------------------------------------------------+--------
  1 | 张三   |  30 | 北京朝阳                                       |   5000
  2 | 李四   |  28 | 上海浦东                                       |   6000
  3 | 王五   |  35 | 广州天河                                       |   7000
  4 | 赵六   |  40 | 深圳南山                                       |   8000
  5 | 陈七   |  25 | 杭州西湖                                       |   5500
(5 rows)

例子：导入两个指定表的定义和数据，在导入之前，表不存在

omm@backupdb=# drop table hr.employee cascade;
NOTICE:  drop cascades to view hr.emp_vw
DROP TABLE

omm@backupdb=# drop table hr.department cascade;
DROP TABLE

[omm@opengauss ~]$ gs_restore -n hr -t employee -n hr -t department -d backupdb backup/stonedb_backup.tar
start restore operation ...
Progress: [==================================================] 100% (17/17, restored_entries/total_entries). restore entires 
end restore operation ...
restore operation successful
total time: 25  ms

openGauss Backup and Recovery

# openGauss Backup and Recovery

# 概述

# 配置文件的备份与恢复

# 逻辑备份与恢复

# gs_dump

# gs_dumpall

# gs_restore

# 物理备份与恢复

# gs_backup

# gs_probackup

# 闪回恢复

# 闪回查询

# 闪回表

# 闪回删除

# 导出数据

# 概述

# 导出单个数据库

# 导出模式

# 导出表

# 导出所有数据库

# 导出全局对象

# 导入数据

# COPY

# 元命令导入数据

# gs_restore 命令导入数据

openGauss Backup and Recovery

概述

配置文件的备份与恢复

逻辑备份与恢复

gs_dump

gs_dumpall

gs_restore

物理备份与恢复

gs_backup

gs_probackup

闪回恢复

闪回查询

闪回表

闪回删除

导出数据

概述

导出单个数据库

导出模式

导出表

导出所有数据库

导出全局对象

导入数据

COPY

元命令导入数据

gs_restore 命令导入数据