# 元命令参考
使用GaussDB数据库命令行交互工具登录数据库后，gsql提供了一些元命令。连接数据库后，可以使用\\?命令，显示所有可用的元命令帮助信息。
#### 注意事项
- 一个gsql元命令的格式是反斜杠后面紧跟一个动词，然后是任意参数。参数命令动词和其他参数以任意个空白字符间隔。
- 要在参数里面包含空白，必须用单引号把它引起来。要在这样的参数里包含单引号，可以在前面加一个反斜杠。任何包含在单引号里的内容都会被进一步进行类似C语言的替换：\\n（新行）、\\t（制表符）、\\b（退格）、\\r（回车）、\\f（换页）、\\digits（八进制表示的字符）、\\xdigits（十六进制表示的字符）。
- 用反引号"\`"包围的内容被当作一个命令行传入shell。该命令的输出（删除了结尾的新行）会替换原参数中的反引号及其包围的文本，被当作参数值。
- 如果不带引号的参数以冒号（:）开头，它会被当做一个gsql变量，并且该变量的值最终会成为真正的参数值。
- 有些命令以一个SQL标识的名称（比如一个表）为参数。这些参数遵循SQL语法关于双引号的规则：不带双引号的标识强制转换成小写，而双引号保护字母不进行大小写转换，并且允许在标识符中使用空白。在双引号中，成对的双引号在结果名称中分析成一个双引号。比如，FOO"BAR"BAZ解析成fooBARbaz；而"Aweird""name"解析成Aweird"name。
- 对参数的分析在遇到另一个不带引号的反斜杠时停止，这里会认为是一个新的元命令的开始。特殊的双反斜杠序列（\\\\）标识参数的结尾，并将继续分析后面的SQL语句。这样SQL和gsql命令可以在一行中混合使用。但是在任何情况下，一条元命令的参数不能延续超过行尾。
- M-Compatibility模式数据库不支持\\h元命令。
 
#### 命令格式及参数说明
元命令的详细说明请参见[表1]、[表2]、[表3]、[表4]、[表6]、[表8]、[表9]、[表10]和[表12]。
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
以下命令中所提到的FILE代表文件路径。此路径可以是绝对路径（如/home/gauss/file.txt），也可以是相对路径（如file.txt，file.txt会默认在用户执行gsql命令所在的路径下创建）。
 表1一般的元命令 
| 参数                                 | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 取值范围                                                          |
|:---|:---|:---|
| \\copyright                         | 显示GaussDB的版本和版权信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           | -                                                             |
| \\g \[FILE\] or ;                 | 执行查询（并将结果发送到文件或管道）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | -                                                             |
| \\h(\\help) \[NAME\]               | 给出指定SQL语句的语法帮助。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 如果没有给出NAME，gsql将列出可获得帮助的所有命令。如果NAME是一个星号（\*），则显示所有SQL语句的语法帮助。 |
| \\parallel \[on \[num\]\|off\] | 控制并发执行开关。 - on：打开控制并发执行开关，且最大并发数为num。num的默认值为1024。  - off：关闭控制并发执行开关。   说明： - 不支持事务中开启并发执行以及并发中开启事务。  - 不支持\\d这类元命令的并发。  - 并发select返回结果混乱问题可接受，core、进程停止响应不可接受。  - 不推荐在并发中使用set语句，否则导致结果与预期不一致。  - 不支持创建临时表。如需使用临时表，需要在开启parallel之前创建好，并在parallel内部使用。parallel内部不允许创建临时表。  - \\parallel执行时最多会启动num个独立的gsql进程连接服务器。  - \\parallel中所有作业的持续时间不能超过session_timeout，否则可能会导致并发执行过程中断开连接。  - 在\\parallel on之后一条或多条命令，会等到\\parallel off执行后才会执行，因而，\\parallel on之后需要有对应的\\parallel off，否则\\parallel on后的命令都无法执行。  - 服务器能接受的最大连接数受max_connection及当前已有连接数限制。设置num时，请根据服务器当前可接受的实际连接数合理指定。   | -                                                                                                      |
| \\q                                | 退出gsql程序。在一个脚本文件里，只在脚本终止时执行。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | -                                                          |
   
 表2查询缓存区元命令 
| 参数                                                                  | 参数说明                                                                                                   |
|:---|:---|
| \\e \[FILE\] \[LINE\]                                               | 使用外部编辑器编辑查询缓冲区（或者文件）。                                                                                   |
| \\ef \[FUNCNAME \[LINE\]\]                                          | 使用外部编辑器编辑函数定义。如果指定了LINE（即行号），则光标会指到函数体的指定行。                                                            |
| \\p                                                                  | 打印当前查询缓冲区到标准输出。                                                                                        |
| \\r                                                                 | 重置（或清空）查询缓冲区。                                                                                          |
| \\w FILE \\w \|COMMAND | 将当前查询缓冲区输出到FILE指定的文件。 将当前查询缓冲区通过管道发送给COMMAND指定的shell命令。 |
   
 表3输入/输出元命令 
| 参数                                                                                                                                                                                                   | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
|:---|:---|
| \\copy { table \[ ( column_list ) \] \| ( query ) } { from \| to } { filename \| stdin \| stdout \| pstdin \| pstdout }\[copy_parameter\] \[parallel integer\] \[NO_SPLIT_FILE\]\[FIELD_NO_EOL\] | 在任何gsql客户端登录数据库成功后可以执行导入导出数据，这是一个运行SQL COPY命令的操作，但不是读取或写入指定文件的服务器，而是读取或写入文件，并在服务器和本地文件系统之间路由数据。这意味着文件的可访问性和权限是本地用户的权限，而不是服务器的权限，并且不需要数据库初始化用户权限。 说明： - \\COPY只适合小批量，格式良好的数据导入，导入数据应优先选择GDS或COPY。  - \\COPY可以指定数据导入时的客户端数量，从而实现数据文件的并行导入，目前并发数范围为\[1, 客户端CPU核数的两倍\]。  - \\COPY指定parallel参数进行并行导入时，将启动多个线程导入数据，每个线程都是单独的事务，可能出现数据部分导入的结果。请在充分理解并行可能造成的结果后，谨慎使用并行导入数据。  - \\COPY可以指定pstdin和pstdout。pstdin声明输入是来自gsql的标准输入，pstdout声明输出是来自gsql的标准输出。  - \\COPY并行导入目前存在以下约束： 临时表的并行导入不支持、在事务内的并行导入不支持、对二进制文件的并行导入不支持、数据导入支持AES128加密时不支持以及COPY选项中存在EOL时不支持。在这些情况下，即使指定了parallel参数，仍然会按照非并行流程执行；在数据文件中数据少于100行时，也会按照非并行流程执行。不支持在指定SEQUENCE的场景下进行并行导入，会出现报错。 在对带触发器的表执行并行导入时，若触发器内部存在向带约束的表（记为t1）插入数据的操作，则可能因并行导入导致死锁问题。具体表现为：多个并行导入进程在操作过程中，t1表因约束条件（如唯一键、外键等）导致不同事务间产生锁等待状态，若形成循环等待则触发数据库死锁检测机制，最终导致导入失败并抛出deadlock错误。因此当目标表包含触发器，且触发器逻辑中存在向带约束的表插入数据的操作时，不建议使用并行导入。 在对带约束的表（如唯一约束等）执行并行导入时，如果不使用load语法，若数据文件本身含有违反约束冲突的数据，则可能因并行导入导致死锁问题。具体表现为：多个并行导入线程在操作过程中，t1表因约束条件（如唯一键、外键等）导致不同事务间产生锁等待状态，若形成循环等待则触发数据库死锁检测机制，最终导致数据部分导入失败，并抛出错误。因此当目标表包含约束条件（如唯一键等），建议使用load语法进行并行导入。 FIELD_NO_EOL语法在parallel大于1时生效，在使用FIELD_NO_EOL语法时会加快数据导入的速度，但需要自行确认导入数据文件中的数据行字段内没有包含换行符。如果包含换行符，可能会导致： - 一个完整的数据行被数据字段内的换行符分割为两部分，两部分被分配给不同的线程向客户端发送数据，导致插入字段与表结构不匹配的错误。  - 在使用skip语法时会跳过前面指定数量的数据行。字段内的换行符可能让一行数据被误认为是两行数据，导致skip语法跳过的数据行数错误。    - \\COPY新增加NO_SPLIT_FILE语法，当parallel大于1时生效，如果使用该参数，表示使用原有逻辑无法解除并行度最大值为8的限制。默认解除并行度最大值为8的限制，自动拆分数据文件实现并行。  - \\COPY元命令不建议与其它数据库命令放在同一行执行。  - \\COPY语句不允许多行。  - \\COPY中间不能包含注释，否则导致注释后面的语句被截断。  - \\COPY执行时，若遇到\\copy: parse error at end of line报错，建议优先校验当前命令是否完全遵循COPY语法规范，重点关注字段分隔符、导入导出格式相关参数的正确性。  - \\COPY执行时，当通过copy_custom_id等参数传递自定义字符串时，建议避免字符串内容包含EOL、BINARY等COPY语法参数，以防止并行导入出现异常。  - \\COPY仅在设置parallel参数大于1，开启并行时才支持参数skip和limit，功能如下： - skip int_number：指定数据导入时，跳过数据文件的前int_number行。  - limit int_number：指定从输入数据源中最多处理的行数。    - \\COPY支持COPY的所有命令，在参数列表中用copy_parameter来指代，非M兼容下关于COPY所有命令的详细信息请参见[COPY](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/gaussdb-08-0236.html)，M兼容下关于COPY所有命令的详细信息请参见《M-Compatibility开发指南》中"SQL参考 \> SQL语法 \> C \> COPY"章节。   |
| \\echo \[STRING\]                                                                                                                                                                                    | 把字符串写到标准输出。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| prompt \[STRING\]                                                                                                                                                                                                                              | 把字符串写到标准输出（等同于\\echo）。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| \\i FILE                                                                                                                                                                                              | 从文件FILE中读取内容，并将其当作输入，执行查询。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| \\i+ FILE KEY                                                                                                                                                                                        | 执行加密文件中的命令。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| \\ir FILE                                                                                                                                                                                            | 和\\i类似，只是相对于存放当前脚本的路径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| \\ir+ FILE KEY                                                                                                                                                                                       | 和\\i+类似，只是相对于存放当前脚本的路径。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| \\o \[FILE\]                                                                                                                                                                                         | 把后续所有查询结果发送到FILE指定的文件里。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| \\o \[\|COMMAND\]                                                                                                                                                                                                                             | 把后续所有查询结果通过管道发送给COMMAND指定的shell命令。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| \\qecho \[STRING\]                                                                                                                                                                                   | 把字符串写到查询结果输出流里。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| \\print_copy_lines \[on \| off\]                                                                                                                                                                                                               | 切换COPY FROM STDIN命令是否打印"COPY XXX"回显，默认开启。 - on：COPY FROM STDIN命令打印当前导入多少行数据。  - off：COPY FROM STDIN命令不打印当前导入多少行数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
 表4显示信息元命令 
| 参数                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | 参数说明                                                                                                                                                                                                                                                                                                                                          | 取值范围                     | 示例                                                                                                                                                                                                                                                                                                                                                                    |
|:---|:---|:---|:---|
| \\d\[S+\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | 列出当前search_path中模式下所有的表、视图和序列。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。                                                                                                                                                                                                                                                         | -                        | 列出当前search_path中模式下所有的表、视图和序列。 ``` gaussdb=#  \d ```                                                                                                                                                                                                                                                                                                                |
| \\d\[S+\] NAME                                                                                                                                                                                                                                                                                                                                                                                                                                                                     | 列出指定表、视图和索引的结构。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。                                                                                                                                                                                                                                                                        | -                     | 假设存在表a，列出指定表a的结构。 ``` gaussdb=#  \dtable+ a ```                                                                                                                                                                                                                                                                                                                        |
| \\d+ \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 列出所有表、视图和索引。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的表、视图和索引。                                                                                                                                                                                                                                      | -                        | 列出所有名称以f开头的表、视图和索引。 ``` gaussdb=#  \d+ f* ```                                                                                                                                                                                                                                                                                                                        |
| \\da\[S\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有可用的聚集函数，以及它们操作的数据类型和返回值类型。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的聚集函数。                                                                                                                                                                                                                         | -                        | 列出所有名称以f开头可用的聚集函数，以及它们操作的数据类型和返回值类型。 ``` gaussdb=#  \da f* ```                                                                                                                                                                                                                                                                                                      |
| \\db\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有可用的表空间。如果声明了PATTERN，只显示名称匹配PATTERN的表空间。                                                                                                                                                                                                                                                                                                 | -                        | 列出所有名称以p开头的可用表空间。 ``` gaussdb=#  \db p* ```                                                                                                                                                                                                                                                                                                                          |
| \\dc\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有字符集之间的可用转换。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的转换。                                                                                                                                                                                                                                         | -                        | 列出所有字符集之间的可用转换。 ``` gaussdb=#  \dc * ```                                                                                                                                                                                                                                                                                                                             |
| \\dC\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有类型转换。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的转换。                                                                                                                                                                                                                                               | PATTERN需要使用实际类型名，不能使用别名。 | 列出所有名称以c开头的类型转换。 ``` gaussdb=#  \dC c* ```                                                                                                                                                                                                                                                                                                                              |
| \\dd\[S\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 显示所有可视对象。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配的对象。对象包括：聚集、函数、操作符、类型、关系(表、视图、索引、序列)、规则。                                                                                                                                                                                                                  | -                        | 列出所有可视对象。 ``` gaussdb=#  \dd ```                                                                                                                                                                                                                                                                                                                                       |
| \\ddp \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 显示所有默认的使用权限。如果指定了PATTERN，只显示名称匹配PATTERN的使用权限。                                                                                                                                                                                                                                                                                               | -                        | 列出所有默认的使用权限。 ``` gaussdb=#  \ddp ```                                                                                                                                                                                                                                                                                                                                  |
| \\dD\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有可用域。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的域。                                                                                                                                                                                                                                                 | -                        | 列出所有可用域。 ``` gaussdb=#  \dD ```                                                                                                                                                                                                                                                                                                                                        |
| \\det\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有的外部表。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的表。                                                                                                                                                                                                                                                 | -                        | 列出所有的外部表。 ``` gaussdb=#  \det ```                                                                                                                                                                                                                                                                                                                                     |
| \\des\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有的外部服务器。如果声明了PATTERN，只显示名称匹配PATTERN的服务器。                                                                                                                                                                                                                                                                                                 | -                        | 列出所有的外部服务器。 ``` gaussdb=#  \des ```                                                                                                                                                                                                                                                                                                                                  |
| \\deu\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出用户映射信息。如果声明了PATTERN，只显示名称匹配PATTERN的信息。                                                                                                                                                                                                                                                                                                    | -                        | 列出用户映射信息。 ``` gaussdb=#  \deu ```                                                                                                                                                                                                                                                                                                                                     |
| \\dew\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出封装的外部数据。如果声明了PATTERN，只显示名称匹配PATTERN的数据。                                                                                                                                                                                                                                                                                                   | -                        | 列出封装的外部数据。 ``` gaussdb=#  \dew ```                                                                                                                                                                                                                                                                                                                                     |
| \\df\[antw\]\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                | 列出所有可用函数，以及它们的参数和返回的数据类型。a代表聚集函数，n代表普通函数，t代表触发器，w代表窗口函数。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的函数。                                                                                                                                                                                               | -                        | 列出所有可用函数，以及它们的参数和返回的数据类型。 ``` gaussdb=#  \df ```                                                                                                                                                                                                                                                                                                                       |
| \\dF\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有的文本搜索配置信息。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的配置信息。                                                                                                                                                                                                                                         | -                        | 列出所有的文本搜索配置信息。 ``` gaussdb=#  \dF+ ```                                                                                                                                                                                                                                                                                                                                |
| \\dFd\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有的文本搜索字典。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的字典。                                                                                                                                                                                                                                            | -                        | 列出所有的文本搜索字典。 ``` gaussdb=#  \dFd ```                                                                                                                                                                                                                                                                                                                                   |
| \\dFp\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有的文本搜索分析器。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的分析器。                                                                                                                                                                                                                                           | -                        | 列出所有的文本搜索分析器。 ``` gaussdb=#  \dFp ```                                                                                                                                                                                                                                                                                                                                 |
| \\dFt\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有的文本搜索模板。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只显示名称匹配PATTERN的模板。                                                                                                                                                                                                                                            | -                        | 列出所有的文本搜索模板。 ``` gaussdb=#  \dFt ```                                                                                                                                                                                                                                                                                                                                 |
| \\dg\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有数据库角色。如果指定了PATTERN，只显示名称匹配PATTERN的角色。 说明： 因为用户和群组的概念被统一为角色，所以这个命令等价于\\du。为了和以前兼容，所以保留两个命令。                                                                                                                                                       | -                        | 列出名称为"j?e"所有数据库角色（"?"表示任一字符）。 ``` gaussdb=#  \dg j?e ```                                                                                                                                                                                                                                                                                                               |
| \\dL\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出可用的程序语言。如果指定了PATTERN，只列出名称匹配PATTERN的语言。                                                                                                                                                                                                                                                                                                     | -                        | 列出可用的程序语言。 ``` gaussdb=#  \dL ```                                                                                                                                                                                                                                                                                                                                     |
| \\dm\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | 列出物化视图。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果指定了PATTERN，只列出名称匹配PATTERN的物化视图。                                                                                                                                                                                                                                                                                         | -                                                                  | 列出物化视图。 ``` gaussdb=#  \dm ```                                                                                                                                                                                                                                                                                                                                         |
| \\dn\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有模式（名称空间）。如果向命令追加+，会列出每个模式相关的权限及描述。如果声明了PATTERN，只列出名称匹配PATTERN的模式名。缺省时，只列出用户创建的模式。                                                                                                                                                                                                                                                       | -                                                                 | 列出所有名称以d开头的模式以及相关信息。 ``` gaussdb=#  \dn+ d* ```                                                                                                                                                                                                                                                                                                                       |
| \\do\[S\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                             | 列出所有可用的操作符，以及它们的操作数和返回的数据类型。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只列出名称匹配PATTERN的操作符。缺省时，只列出用户创建的操作符。                                                                                                                                                                                                           | -                        | 列出所有可用的操作符，以及它们的操作数和返回的数据类型。 ``` gaussdb=#  \do ```                                                                                                                                                                                                                                                                                                                   |
| \\dO\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出排序规则。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果声明了PATTERN，只列出名称匹配PATTERN的规则。缺省时，只列出用户创建的规则。                                                                                                                                                                                                                                    | -                        | 列出排序规则。 ``` gaussdb=#  \dO ```                                                                                                                                                                                                                                                                                                                                         |
| \\dp \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 列出可用的表、视图以及相关的权限信息。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果指定了PATTERN，只列出名称匹配PATTERN的表、视图。                                                                                                                                                                                                                                   | -                                                                  | 列出可用的表、视图以及相关的权限信息。 ``` gaussdb=#  \dp ``` \\dp显示结果如下： ``` rolename=xxxx/yyyy  --赋予一个角色的权限 ``` ``` =xxxx/yyyy  --赋予public的权限 ``` xxxx表示赋予的权限，yyyy表示授予这个权限的角色。权限的参数说明请参见[表5]。 |
| \\drds \[PATTERN1 \[PATTERN2\]\]                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 列出所有修改过的配置参数。这些设置可以是针对角色的、针对数据库的或者同时针对两者的。PATTERN1和PATTERN2表示要列出的角色PATTERN和数据库PATTERN。如果声明了PATTERN，只列出名称匹配PATTERN的规则。缺省或指定\*时，则会列出所有设置。                                                                                                                                                                                                     | -                        | 列出数据库所有修改过的配置参数。 ``` gaussdb=#  \drds * dbname ```                                                                                                                                                                                                                                                                                                                   |
| \\dT\[S+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                            | 列出所有的数据类型。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。如果指定了PATTERN，只列出名称匹配PATTERN的类型。                                                                                                                                                                                                                                              | -                        | 列出所有的数据类型。 ``` gaussdb=#  \dT ```                                                                                                                                                                                                                                                                                                                                      |
| \\du\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 列出所有数据库角色。如果指定了PATTERN，则只列出名称匹配PATTERN的角色。 说明： 因为用户和群组的概念被统一为角色，所以这个命令等价于\\dg。为了和以前兼容，所以保留两个命令。                                                                                                                                                      | -                                                                   | 列出所有数据库角色。 ``` gaussdb=#  \du ```                                                                                                                                                                                                                                                                                                                                    |
| \\dE\[S+\] \[PATTERN\] \\di\[S+\] \[PATTERN\] \\ds\[S+\] \[PATTERN\] \\dt\[S+\] \[PATTERN\] \\dv\[S+\] \[PATTERN\] | 这一组命令，字母E、i、s、t和v分别代表着外部表、索引、序列、表和视图。可以以任意顺序指定其中一个或者它们的组合来列出这些对象。当search_path中不同模式存在同名对象时，只显示search_path中位置靠前模式下的同名对象。例如：\\dit列出所有的索引和表。如果指定了PATTERN，只列出名称匹配该PATTERN的对象。默认情况下只会显示用户创建的对象。通过PATTERN或者S修饰符可以把系统对象包括在内。                                                                                                                        | -                        | 列出所有的索引和视图。 ``` gaussdb=#  \div ```                                                                                                                                                                                                                                                                                                                                    |
| \\dx\[+\] \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                              | 列出安装数据库的扩展信息。如果指定了PATTERN，则只列出名称匹配PATTERN的扩展信息。                                                                                                                                                                                                                                                                                             | -                     | 列出安装数据库的扩展信息。 ``` gaussdb=#  \dx ```                                                                                                                                                                                                                                                                                                                                  |
| \\l\[+\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                          | 列出服务器上所有数据库的名称、所有者、字符集编码以及使用权限。                                                                                                                                                                                                                                                                                                             | -                        | 列出服务器上所有数据库的名称、所有者、字符集编码以及使用权限。 ``` gaussdb=#  \l ```                                                                                                                                                                                                                                                                                                                  |
| \\sf\[+\] FUNCNAME                                                                                                                                                                                                                                                                                                                                                                                                                                                                 | 显示函数的定义。 说明： - 对于带圆括号的函数名，需要在函数名两端添加双引号，并且在双引号后面加上参数类型列表。参数类型列表两端添加圆括号。  - 如果存在同名的函数，则会返回多个函数的定义。   | -                        | 假设存在函数function_a和函数名带圆括号的函数func()name，列出函数的定义。 ``` gaussdb=#  \sf function_a gaussdb=#  \sf "func()name"(argtype1, argtype2) ```                                                                                                                                                                                                                                      |
| \\z \[PATTERN\]                                                                                                                                                                                                                                                                                                                                                                                                                                                                  | 列出数据库中所有表、视图和序列，以及它们相关的访问特权。如果给出任何PATTERN，则被当成一个正则表达式，只显示匹配的表、视图、序列。                                                                                                                                                                                                                                                                                                                 | -                        | 列出数据库中所有表、视图和序列，以及它们相关的访问特权。 ``` gaussdb=#  \z ```                                                                                                                                                                                                                                                                                                                    |
   
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- [表4]中的选项S表示显示系统对象，+表示显示对象附加的描述信息。
- PATTERN用来指定要被显示的对象名称。关于PATTERN的注意事项如下：
  - 在最简单的情况下，PATTERN是该对象的准确名称。在PATTERN中的字符通常会被变成小写形式（和在SQL名称中相同），例如\\dt FOO将会显示名为foo的表。和在SQL名称中相同，把PATTERN放在双引号中可以阻止它被转换成小写形式。如果需要在一个PATTERN中包括一个真正的双引号字符，则需要把它写成两个相邻的双引号，这同样是符合SQL引用标识符的规则。例如，\\dt "FOO""BAR"将显示名为FOO"BAR（不是foo"bar）的表。和普通的SQL名称规则不同，不能只在PATTERN的一部分周围放上双引号，例如\\dt FOO"FOO"BAR将会显示名为fooFOObar的表。
  
  - 不使用PATTERN参数时，\\d命令会显示当前schema搜索路径中可见的全部对象------这等价于用\*作为PATTERN。所谓对象可见是指可以直接用名称引用该对象，而不需要用schema来进行限定。要查看数据库中所有的对象而不管它们的可见性，可以把\*.\*用作PATTERN。
  
  - 如果放在一个PATTERN中，\*将匹配任意字符序列（包括空序列），而?会匹配任意的单个字符（和Unix shell的文件名PATTERN相同）。例如，\\dt int\*会显示名称以int开始的表。但是如果被放在双引号内，\*和?就会失去这些特殊含义而变成普通的字符。
  
  - 包含一个点号（.）的PATTERN被解释为一个schema名称模式后面跟上一个对象名称模式。例如，\\dt foo\*.\*bar\*会显示名称以foo开始的schema中所有名称包括bar的表。如果没有出现点号，那么模式将只匹配当前schema搜索路径中可见的对象。同样，双引号内的点号会失去其特殊含义并且变成普通的字符。
  
  - 高级用户可以使用字符类等正则表达式记法，如\[0-9\]可以匹配任意数字。所有的正则表达式特殊字符都按照POSIX正则表达式使用。以下字符除外：
    - .会按照上文所述作为一种分隔符。
    
    - \*会被翻译成正则表达式记号.\*。
    
    - ?会被翻译成.。
    
    - $则按字面意思匹配。
     
  
  - 根据需要，可以通过书写?、(*R* +\|)、(*R* \|)和*R* ?来分别模拟PATTERN字符.、*R* \*和*R*?。$不需要作为一个正则表达式字符，因为PATTERN必须匹配整个名称，而不是按照正则表达式的常规用法解释（换句话说，$会被自动地追加到PATTERN上）。如果不希望该PATTERN的匹配位置被固定，可以在开头或者结尾写上\*。注意在双引号内，所有的正则表达式特殊字符会失去其特殊含义并且按照其字面意思进行匹配。另外，在操作符名称PATTERN中（即\\do的PATTERN参数），正则表达式特殊字符也按照字面意思进行匹配。
   
 
 表5权限的参数说明 
| 参数    | 参数说明                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
|:---|:---|
| r     | SELECT：允许对指定的表、视图读取数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| w     | UPDATE：允许对指定表更新字段。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| a     | INSERT：允许对指定表插入数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| d     | DELETE：允许删除指定表中的数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
| D     | TRUNCATE：允许清理指定表中的数据。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| x     | REFERENCES：允许创建外键约束，分布式场景暂不支持。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| t     | TRIGGER：允许在指定表上创建触发器。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| X     | EXECUTE：允许使用指定的函数，以及利用这些函数实现的操作符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| U     | USAGE： - 对于过程语言，允许用户在创建函数时，指定过程语言。  - 对于模式，允许访问包含在指定模式中的对象。  - 对于序列，允许使用nextval函数。                           |
| C  | CREATE： - 对于数据库，允许在该数据库里创建新的模式。  - 对于模式，允许在该模式中创建新的对象。  - 对于表空间，允许在其中创建表，以及允许创建数据库和模式的时候把该表空间指定为其缺省表空间。   |
| c  | CONNECT：允许用户连接到指定的数据库。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| T     | TEMPORARY：允许创建临时表。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| A     | ALTER：允许用户修改指定对象的属性。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
| P                                              | DROP：允许用户删除指定的对象。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| m                                                | COMMENT：允许用户定义或修改指定对象的注释。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| i                                                | INDEX：允许用户在指定表上创建索引。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| v                                               | VACUUM：允许用户对指定的表执行ANALYZE和VACUUM操作。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| \* | 授权以上权限。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
   
 表6格式化元命令 
| 参数                       | 参数说明                                      | 取值范围                                                                                                                                                                                                                                                                                                                                                                               |
|:---|:---|:---|
| \\a                      | 对齐模式和非对齐模式之间的切换。                          | -                                                                                                                                                                                                                                                                                                                                                                                |
| \\C \[STRING\]          | 为表输出设置标题，或者取消标题（如果没有参数）。                 | 任意字符串或空。                                                                                                                                                                                                                                                                                                                                                                        |
| \\f \[STRING\]            | 指定在非对齐输出模式下，用于分隔字段的字符或字符串。                | 任意字符串。                                                                                                                                                                                                                                                                                                                                                                           |
| \\H                      | 标准输出和HTML表格格式输出之间的切换。                                                              | -                                                                                                                                                                                                                                                                                                                                                                                |
| \\pset NAME \[VALUE\]    | 设置影响查询结果表输出的选项。                           | NAME的取值见[表7]。                                                                                                                                                                                                                                                                         |
| \\t \[on \| off\]        | 切换输出的表格格式。                                | - on：只显示数据行，不显示列标题和行计数。  - off：显示完整的表格，包括列标题和行计数。                                                                                                                                     |
| \\T \[STRING\]           | 指定在使用HTML输出格式时放在table标签里的属性。如果参数为空，表示不设置。 | -                                                                                                                                                                                                                                                                                                                                                                                 |
| \\x \[on \| off \| auto\] | 切换扩展行显示模式。                                 | - on：启用扩展显示模式，每个字段单独一行显示。  - off：禁用扩展显示模式，使用标准表格显示。  - auto：根据查询结果的宽度自动选择是否使用扩展显示模式。   |
   
 表7可调节的打印选项 
| 选项              | 选项说明                                                                                         | 取值范围                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
|:---|:---|:---|
| border          | 用于控制表格输出时的边框样式。                                                                              | - 在HTML格式下，取值范围为大于0的整数。  - 在其他格式下，取值范围： - 0：无边框，表格输出时不显示任何边框线。  - 1：内部边框，显示列之间的分隔线，但不显示表格的外边框。  - 2：完整边框，显示外边框和内部分隔线。     |
| expanded (或x)   | 在正常和扩展格式之间切换。                                                                                | - on：启用扩展显示模式，每个字段单独一行显示。  - off：禁用扩展显示模式，使用标准表格显示。标准格式只对aligned和wrapped格式有意义。  - auto：根据查询结果的宽度自动选择是否使用扩展显示模式。                                                                                                                                                                                                                                                                                                                                                                                                              |
| fieldsep        | 用于控制在非对齐输出模式下，各个字段之间的分隔符。                                                                     | 可以设置为任意字符串。常见的取值包括","、"\\t"、"\|"等，如果不设置该选项，默认使用空格作为字段分隔符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    |
| fieldsep_zero   | 用于设置未对齐输出模式下的字段分隔符为ASCII NUL字符。                                                              | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| footer           | 用于设置查询结果的页脚。                                                                                 | - on：显示页脚信息。  - off：不显示页脚信息。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| format          | 控制查询结果的输出格式。                                                                                 | - unaligned（u）：以未对齐的形式显示，字段之间使用当前的字段分隔符分隔。  - aligned（a）：以对齐的表格形式显示。  - wrapped（w）：与aligned类似，但会自动换行过长的值。  - html（h）：以HTML表格格式显示。  - latex（l）：以LaTeX表格格式显示。  - troff-ms（t）：以troff ms宏格式显示。                                         |
| null            | 用于设置NULL值的显示方式。                                                                               | 任意字符串。如果不设置该选项，默认使用空白字符来代替NULL值。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| numericlocale   | 用于控制数字输出格式时是否使用当前系统的区域设置。                                                                    | - on：数字输出时会使用当前系统的区域设置进行格式化。例如，在英语环境下，数字1,000.00会显示为1,000.00，在德语环境下会显示为1.000,00。  - off：数字输出时不使用区域设置，而是使用标准的数字格式，如1000.00。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
| pager           | 控制查询和gsql帮助输出的分页器。如果设置了环境变量PAGER，输出将被指向到指定程序，否则使用系统缺省。                                       | - on：当输出到终端且不适合屏幕显示时，使用分页器。  - off：不使用分页器。  - always：当输出到终端无论是否符合屏幕显示时，都使用分页器。                                                                                                                                                                                         |
| recordsep       | 用于设置未对齐输出模式下的记录分隔符。                                                                          | 可以设置为任意字符串。常见的取值包括换行符\\n、回车符\\r、回车换行符\\r\\n等。如果不设置该选项，默认使用换行符\\n作为记录分隔符。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| recordsep_zero  | 用于设置未对齐输出模式下的记录分隔符为ASCII NUL字符。                                                              | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| tableattr（或T）   | 声明放在HTML输出格式中HTML table标签的属性（例如：cellpadding或bgcolor）。注意：如果已经使用\\pset border命令，这里无需再设置border。 | 例如bgcolor=#FFFFFF等。如果没有给出value，则表示不设置表的属性。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| title            | 用于设置查询结果的标题。                                                                                 | 可以设置为任意字符串，如果不设置该选项，查询结果将不会显示任何标题。                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
| tuples_only（或t） | 在完全显示和只显示实际的表数据之间切换。完全显示将输出像列头、标题、各种脚注等信息。在tuples_only模式下，只显示实际的表数据。                         | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| feedback                                                 | 切换是否输出结果行数。                                                                                                                          | -                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
   
 表8连接元命令 
| 参数                                                  | 参数说明                                                                                                                                                                                                                               | 取值范围             |
|:---|:---|:---|
| \\c\[onnect\] \[DBNAME\|- USER\|- HOST\|- PORT\|-\] | 连接到一个新的数据库。当数据库名称长度超过63个字节时，默认前63个字节有效，连接到前63个字节对应的数据库，但是gsql的命令提示符中显示的数据库对象名仍为截断前的名称。 说明： 重新建立连接时，如果切换数据库登录用户，可能会出现交互式输入，要求输入新用户的连接密码。该密码最大长度为999字节，受限于GUC参数password_max_length的最大值。 | -                |
| \\encoding \[ENCODING\]                             | 设置客户端字符编码格式。                                                                                                                                                                                                                       | 不带参数时，显示当前的编码格式。 |
| \\conninfo                                          | 输出当前连接的数据库的信息。                                                                                                                                                                                                                     | -                |
   
 表9操作系统元命令 
| 参数                      | 参数说明                                          | 取值范围                                                                                                                                                                                                                                                                                                                                                                                              |
|:---|:---|:---|
| \\cd \[DIR\]            | 切换当前的工作目录。                                    | 绝对路径或相对路径，且满足操作系统路径命名规则。                                                                                                                                                                                                                                                                                                                                                                          |
| \\setenv NAME \[VALUE\] | 设置环境变量NAME为VALUE，如果没有给出VALUE值，则不设置环境变量。       | -                                                                                                                                                                                                                                                                                                                                                                                                 |
| \\timing \[on \| off\]  | 以毫秒为单位显示每条SQL语句的执行时间（不包括屏显打印时间）。              | - on：表示打开显示。  - off：表示关闭显示。   |
| \\! \[COMMAND\]         | 用于执行操作系统的命令。如果不跟任何参数，\\!会直接打开一个独立的shell供用户交互。 | -                                                                                                                                                                                                                                                                                                                                                                                                 |
   
 表10变量元命令 
| 参数                      | 参数说明                                                                                                                                                                                                                                                                                                                                |
|:---|:---|
| \\prompt \[TEXT\] NAME  | 用于提示用户输入一个值，并将其存储在一个gsql变量中。TEXT表示提示用户输入的文本，NAME表示要将输入值存储的gsql变量。示例如下： ``` gaussdb=#  \prompt 'Enter area name: ' area Enter area name: Asia gaussdb=#  SELECT * FROM HR.areaS WHERE area_name = :'area'; area_id | area_name ---------+----------- 3 | Asia (1 row) ```                                                            |
| \\set \[NAME \[VALUE\]\] | 设置内部变量NAME为VALUE，如果给出了多于一个值，变量取值为所有值的连接结果。如果没有给出第二个参数，只设置变量不设置值。 有一些常用变量被gsql特殊对待，它们是一些选项设置，通常所有特殊对待的变量都是由大写字母组成（可能还有数字和下划线）。 [表11]是所有被特殊对待的变量列表。 |
| \\unset NAME            | 不设置（或删除）gsql变量名。                                                                                                                                                                                                                                                                                                                    |
   
 表11\\set常用命令 
| 名称                               | 命令说明                                                                                                                                                                                                                                                  | 取值范围                                                                                                                                                                                                                                                                                                                                                                                                                                     |
|:---|:---|:---|
| \\set VERBOSITY value         | 该选项用于控制错误报告的冗余行。                                                                                                                                                                                                                                      | - default：返回严重且主要的错误文本及其位置，还包括详细的错误细节、错误提示（可能会跨越多行）。  - verbose：返回所有的错误信息。  - terse：仅返回严重且主要的错误文本以及文本位置（一般适合于单行错误信息）。                                                                 |
| \\set ON_ERROR_STOP value  | 如果设置了这个变量，脚本处理将马上停止。如果该脚本是从另外一个脚本调用的，另外一个脚本也会按同样的方式停止。如果最外层的脚本不是从一次交互的gsql会话中调用的而是用-f选项调用的，gsql将返回错误代码3，以示这个情况与致命错误条件的区别（错误代码为1）。                                                                                                                  | - on：命令执行错误时会立即停止，在交互模式下，gsql会立即返回已执行命令的结果。  - off：命令执行错误时将会跳过错误继续执行。   |
| \\set AUTOCOMMIT \[on \| off\]                                            | 控制当前gsql连接的自动提交行为。默认情况下，gsql连接处于自动提交模式，每个单独的语句都被隐式提交。如果基于性能或者其他方面考虑，关闭自动提交时，需要用户自己显式发出COMMIT命令来保证事务的提交。例如，在指定的业务SQL执行完之后发送COMMIT语句显式提交，特别是gsql客户端退出之前务必保证所有的事务已经提交。 说明： gsql默认使用自动提交模式，若关闭自动提交，将会导致后面执行的语句都被隐式事务包裹，数据库中不支持在事务中执行的语句不能在此模式下执行。 | - on：表示打开自动提交。  - off：表示关闭自动提交。                                                                                                                                                                                                                                                       |
   
 表12全密态元命令 
| 参数                    | 参数说明                                |
|:---|:---|
| \\send_token           | 全密态功能，传输密钥到服务端缓存，在开启内存解密逃生通道的情况下使用。 |
| \\st                  | 全密态功能，传输密钥到服务端缓存，在开启内存解密逃生通道的情况下使用。   |
| \\clear_token      | 全密态功能，销毁服务端缓存的密钥，在开启内存解密逃生通道的情况下使用。 |
| \\ct                  | 全密态功能，销毁服务端缓存的密钥，在开启内存解密逃生通道的情况下使用。 |
| \\key_info KEY_INFO | 在全密态数据库特性中，设置访问外部密钥管理者的参数。       |
   
![](https://support.huaweicloud.com/distributed-ref-v10-gaussdb/public_sys-resources/note_3.0-zh-cn.png)
- 分布式暂不支持全密态内存解密逃生通道。
- M-Compatibility模式暂不支持全密态数据库。
 
表13常用简易运维元命令 
| 简易运维命令                                                    | 参数解释                                                                                                                                                                                                                                                                                                                | 实际执行的SQL                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                           |
|:---|:---|:---|
| \\view stmt_track {unique_sql_id}                         | stmt_track：记录指定SQL的L2级别的FULLSQL信息。 unique_sql_id：需要记录的SQL的unique_sql_id。                                                                                                                                                                                            | SELECT \* FROM pg_catalog.dynamic_func_control('LOCAL', 'STMT', 'TRACK', '{"{unique_sql_id}", "L2"}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| \\view stmt_untrack {unique_sql_id}                      | stmt_untrack：取消记录指定SQL的L2级别的FULLSQL信息。 unique_sql_id：需要取消记录的SQL的unique_sql_id。                                                                                                                                                                                          | SELECT \* FROM pg_catalog.dynamic_func_control('LOCAL', 'STMT', 'UNTRACK', '{"{unique_sql_id}"}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| \\view stmt_list                                           | stmt_list：查询记录列表。                                                                                                                                                                                                                                                                                                 | SELECT \* FROM pg_catalog.dynamic_func_control('LOCAL', 'STMT', 'LIST', '{}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| \\view stmt_clean                                         | stmt_clean：清理记录列表。                                                                                                                                                                                                                                                                                                  | SELECT \* FROM pg_catalog.dynamic_func_control('LOCAL', 'STMT', 'CLEAN', '{}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
| \\view explain_and_stack {pid}                          | explain_and_stack：查询指定会话的运行时计划及堆栈。 pid：指定会话的pid。                                                                                                                                                                                                                   | SELECT pg_catalog.gs_get_explain(pid), pg_catalog.gs_stack(pid) FROM pg_catalog.pgxc_stat_activity WHERE pid = {pid};                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
| \\view slow_sql {top_n}                                   | slow_sql：查询实时慢SQL情况。 top_n：查询的行数。                                                                                                                                                                                                                                       | SELECT pid, sessionid, pg_catalog.SUBSTRING(query, 0, 100), state, usename, pg_catalog.NOW() - query_start AS elp FROM pg_catalog.pgxc_stat_activity WHERE state != 'idle' AND usename NOT IN ('rdsAdmin', 'rdsMetric', 'rdsBackup', 'rdsRepl', 'dbmind_monitor_agent', 'dbmind_monitor') ORDER BY elp DESC LIMIT {top_n};                                                                                                                                                                                                                                                                         |
| \\view slow_trans {top_n}                                 | slow_trans：查询实时长事务情况。 top_n：查询的行数。                                                                                                                                                                                                                                    | SELECT pid, sessionid, pg_catalog.SUBSTRING(query, 0, 100), state, usename, pg_catalog.NOW() - xact_start AS elp FROM pg_catalog.pgxc_stat_activity WHERE state != 'idle' AND usename NOT IN ('rdsAdmin', 'rdsMetric', 'rdsBackup', 'rdsRepl', 'dbmind_monitor_agent', 'dbmind_monitor') ORDER BY elp DESC LIMIT {top_n};                                                                                                                                                                                                                                                                           |
| \\view wait_event                                          | wait_event（不带参数）：查询当前语句和等待事件。                                                                                                                                                                                                                                                                                         | SELECT a.pid, a.sessionid, a.datname, a.usename, a.client_addr, a.xact_start, a.query_start, (pg_catalog.NOW() - a.query_start)::text "query_runtime", w.wait_status, w.wait_event, w.locktag, w.lockmode, w.block_sessionid, a.query FROM pg_catalog.pgxc_stat_activity a JOIN pg_catalog.pgxc_thread_wait_status w ON a.sessionid = w.sessionid WHERE a.pid \<\> pg_catalog.pg_backend_pid() AND a.state = 'active' AND a.client_addr IS NOT NULL ORDER BY query_runtime DESC;                                                                                                                    |
| \\view wait_event {unique_sql_id} {start_time} {end_time} | wait_event（带有三个参数）：查询指定慢SQL的历史等待事件。 unique_sql_id：要查询的慢SQL的unique_sql_id。 start_time：开始时间。如'2025-01-01 00:00'。 end_time：结束时间。如'2025-01-01 00:00'。                         | SELECT \*, pg_catalog.statement_detail_decode(details, 'plaintext', true) FROM dbe_perf.statement_history WHERE unique_query_id = {unique_sql_id} AND start_time \> {start_time} AND start_time \< {end_time} ORDER BY db_time DESC;                                                                                                                                                                                                                                                                                                                                                             |
| \\view thr_wait_event                                    | thr_wait_event（不带参数）：查询实时整体等待事件。                                                                                                                                                                                                                                                                                     | SELECT wait_status, wait_event, pg_catalog.COUNT(\*) FROM pg_catalog.pgxc_thread_wait_status GROUP BY 1, 2 ORDER BY 3 DESC;                                                                                                                                                                                                                                                                                                                                                                                                                                                                       |
| \\view thr_wait_event {sessionid}                         | thr_wait_event（带有一个参数）：查询指定语句的等待事件。 sessionid：指定的sessionid。                                                                                                                                                                                                          | SELECT \* FROM pg_catalog.pgxc_thread_wait_status WHERE sessionid = {sessionid};                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| \\view gs_asp {start_time} {end_time}                    | gs_asp：查询指定时间段的整体等待事件 start_time：开始时间。如'2025-01-01 00:00'。 end_time：结束时间。如'2025-12-31 23:59'。                                                                                                                            | SELECT wait_status, event, pg_catalog.COUNT(\*) FROM pg_catalog.gs_asp WHERE sample_time BETWEEN {start_time} AND {end_time} GROUP BY 1, 2 ORDER BY 3 DESC;                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| \\view pg_stats {table_name} {att_name}                   | pg_stats：查询指定表的统计信息分布。 table_name：表名。 att_name：列名。                                                                                                                                                                       | SELECT \* FROM pg_catalog.pg_stats WHERE tablename = '{table_name}' AND attname = '{att_name}';                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| \\view autovac {table_name}                               | autovac：查询统计信息更新阈值。 table_name：表名。                                                                                                                                                                                                                                     | SELECT \* FROM pg_catalog.pg_autovac_status('{table_name}'::regclass);                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| \\view thr_pool                                          | thr_pool：查询线程池使用情况。                                                                                                                                                                                                                                                                                                   | SELECT node_name, worker_info FROM dbe_perf.global_threadpool_status;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| \\view failed_proc {proc_name}                           | failed_proc：查询失效的视图或存储过程。 proc_name：失效的函数。                                                                                                                                                                                                                          | SELECT re.ev_class, cl.relname FROM pg_catalog.pg_rewrite re, pg_catalog.pg_class cl WHERE re.ev_action LIKE '%{proc_name}%' AND cl.oid = re.ev_class;                                                                                                                                                                                                                                                                                                                                                                                                                                              |
| \\view failed_proc_pkg                                     | failed_proc_pkg：查询失效存储过程对应的package。                                                                                                                                                                                                                                                                                  | SELECT DISTINCT object_type, pg_catalog.pg_get_userbyid(creator) AS owner, CASE object_type WHEN 'P' THEN ( SELECT DISTINCT pg_catalog.UPPER(pkgname) FROM pg_catalog.gs_package WHERE oid = ( SELECT propackageid FROM pg_catalog.pg_proc WHERE oid = object_oid ) ) WHEN 'B' THEN ( SELECT DISTINCT pg_catalog.UPPER(pkgname) FROM pg_catalog.gs_package WHERE oid = object_oid ) WHEN 'S' THEN ( SELECT DISTINCT pg_catalog.UPPER(pkgname) FROM pg_catalog.gs_package WHERE oid = object_oid ) END package_name FROM pg_catalog.pg_object WHERE valid = 'f' AND object_type IN ('P', 'B', 'S'); |
| \\view failed_index                                       | failed_index：查询不可用的索引。                                                                                                                                                                                                                                                                                                | SELECT a.schemaname, a.relname, a.indexrelname, b.indisusable FROM pg_catalog.pg_stat_user_indexes a, pg_catalog.pg_index b WHERE a.indexrelid = b.indexrelid AND b.indisusable = 'f';                                                                                                                                                                                                                                                                                                                                                                                                             |
| \\view table_size                                         | table_size：查询当前库下所有表的大小，按降序输出。                                                                                                                                                                                                                                                                                        | SELECT schemaname, relname, pg_catalog.pg_total_relation_size(pg_catalog.CONCAT(schemaname, '.', relname)) / 1024 / 1024 / 1024 "GB" FROM pg_catalog.pg_stat_user_tables ORDER BY 3 DESC;                                                                                                                                                                                                                                                                                                                                                                                                           |
| \\view dead_tup {top_n}                                 | dead_tup：查询死元组的数量。 top_n：查询的行数。                                                                                                                                                                                                                                        | SELECT relname, n_live_tup, n_dead_tup, (n_dead_tup / (n_live_tup + 1)) AS rating, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze FROM pg_catalog.pg_stat_user_tables ORDER BY rating DESC, n_dead_tup DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                             |
| \\view table_size {table_name}                           | table_size：查询指定表的大小。 table_name：表名。                                                                                                                                                                                                                                 | SELECT \* FROM pg_catalog.pg_size_pretty(pg_catalog.pg_total_relation_size('{table_name}'::regclass));                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
| \\view login {start_time} {end_time} {ip} {port}         | login：查询指定IP和端口的登录登出信息。 start_time：开始时间。如'2024-01-01 00:00:00'。 end_time：结束时间。如'2025-12-31 23:59:59'。 ip：IP地址。 port：端口。 | SELECT \*, pg_catalog.SUBSTRING( client_conninfo::varchar, pg_catalog.POSITION(client_conninfo::varchar, '@'::varchar) + 1, 15 ) AS ip FROM pg_catalog.pg_query_audit({start_time}, {end_time}) WHERE ip = '{ip}' AND remote_port = '{port}';                                                                                                                                                                                                                                                                                                                                                       |
| \\view mem                                               | mem：查询当前内存使用信息。                                                                                                                                                                                                                                                                                                    | SELECT \* FROM pg_catalog.pg_total_memory_detail;                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| \\view thr_mem {top_n}                                    | thr_mem（带有一个参数）：查询数据库所有线程的内存上下文使用情况。 top_n：查询的行数。                                                                                                                                                                                                                       | SELECT contextname, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize", pg_catalog.SUM(freesize) / 1024 / 1024 "freesize", pg_catalog.COUNT(\*) "sum" FROM pg_catalog.pv_thread_memory_context GROUP BY contextname ORDER BY sum DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                               |
| \\view thr_mem {context_name} {top_n}                      | thr_mem（带有两个参数）：查询使用内存最多的线程的线程id。 context_name：内存上下文的名称。 top_n：查询的行数。                                                                                                                                                  | SELECT \* FROM pg_catalog.pv_thread_memory_detail() WHERE contextname = '{context_name}' ORDER BY totalsize DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| \\view sess_mem {top_n}                                   | sess_mem：查询数据库所有session的内存上下文使用情况。 top_n：查询的行数。                                                                                                                                                                                                                       | SELECT contextname, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize", pg_catalog.SUM(freesize) / 1024 / 1024 "freesize", pg_catalog.COUNT(\*) "sum" FROM pg_catalog.pv_session_memory_context GROUP BY contextname ORDER BY sum DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                             |
| \\view thr_mem_detail {tid} {context_name}                | thr_mem_detail：查询指定线程的内存使用情况。 tid：线程id。 context_name：内存上下文的名称。                                                                                                                                                          | SELECT \* FROM pg_catalog.gs_get_thread_memctx_detail({tid}, '{context_name}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
| \\view sess_mem_tp {context_name}                         | sess_mem_tp：查询指定内存上下文的内存使用情况。 context_name：内存上下文的名称。                                                                                                                                                                                                                | SELECT \* FROM pg_catalog.gs_get_session_memctx_detail('{context_name}');                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          |
| \\view shared_mem {top_n}                                  | shared_mem：查询数据库全局共享内存上下文的使用情况。 top_n：查询的行数。                                                                                                                                                                                                                        | SELECT contextname, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize MB", pg_catalog.SUM(freesize) / 1024 / 1024 "freesize MB", pg_catalog.COUNT(\*) "sum" FROM pg_catalog.pg_shared_memory_detail GROUP BY contextname ORDER BY sum DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                          |
| \\view sess_mem_detail {top_n}                            | sess_mem_detail：查询session级内存上下文的使用情况。 top_n：查询的行数。                                                                                                                                                                                                                     | SELECT contextname, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize MB", pg_catalog.COUNT(1) "count" FROM pg_catalog.pv_session_memory_detail() GROUP BY contextname ORDER BY 2 DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                                                             |
| \\view sess_mem_detail_tp {top_n}                       | sess_mem_detail_tp：查询session级内存上下文的使用情况(仅在线程池模式开启时生效)。 top_n：查询的行数。                                                                                                                                                                                                   | SELECT sessid, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize MB", pg_catalog.COUNT(1) "count" FROM pg_catalog.pv_session_memory_context GROUP BY sessid ORDER BY 2 DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                                                                        |
| \\view thr_mem_pv {top_n}                                | thr_mem_pv：查询线程级内存上下文的使用情况。 top_n：查询的行数。                                                                                                                                                                                                                             | SELECT contextname, pg_catalog.SUM(totalsize) / 1024 / 1024 "totalsize", pg_catalog.SUM(freesize) / 1024 / 1024 "freesize", pg_catalog.COUNT(1) "count" FROM pg_catalog.pv_thread_memory_detail() GROUP BY 1 ORDER BY 2 DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                      |
| \\view total_mem {top_n}                                 | total_mem：查询当前数据库节点的内存使用情况。 top_n：查询的行数。                                                                                                                                                                                                                             | SELECT \* FROM pg_catalog.pg_total_memory_detail LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  |
| \\view avg_cpu {top_n}                                    | avg_cpu：查询SQL语句的平均CPU时间，按降序输出。 top_n：查询的行数。                                                                                                                                                                                                                         | SELECT unique_sql_id, cpu_time / (n_calls) "average_cpu_time" FROM dbe_perf.statement WHERE n_calls != 0 ORDER BY 2 DESC LIMIT {top_n};                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
| \\om create_abort_sql_patch {patch_name} {unique_sql_id}    | create_abort_sql_patch：创建避险SQL PATCH。 patch_name：SQL PATCH名。 unique_sql_id：指定SQL的unique_sql_id。                                                                                                                      | SELECT \* FROM dbe_sql_util.create_abort_sql_patch('{patch_name}', {unique_sql_id});                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               |
| \\om kill_sess_thr {username} {database} {context_name}   | kill_sess_thr：根据线程内存占用查杀内存占用高的SQL语句。 username：用户名。 database：数据库名。 context_name：内存上下文的名称。                                                                               | EXECUTE DIRECT ON COORDINATORS 'SELECT pg_catalog.pg_terminate_session(pid, sessionid), pid, sessionid FROM pg_catalog.pgxc_stat_activity WHERE usename = ''{username}'' AND datname != ''postgres'' AND datname = ''{database}'' AND pid IN ( SELECT tid FROM pg_catalog.pv_thread_memory_context WHERE contextname = ''{context_name}'' ) AND state = ''idle'';';                                                                                                                                                                                                                                  |
| \\om kill_sess_sess {username} {database} {context_name}  | kill_sess_sess：根据session内存占用查杀内存占用高的SQL语句。 username：用户名。 database：数据库名。 context_name：内存上下文的名称。                                                                         | EXECUTE DIRECT ON COORDINATORS 'SELECT pg_catalog.pg_terminate_session(pid, sessionid), pid, sessionid FROM pg_catalog.pgxc_stat_activity WHERE usename = ''{usename}'' AND datname != ''postgres'' AND datname = ''{database}'' AND pid IN ( SELECT threadid FROM pg_catalog.pv_session_memory_context WHERE contextname = ''{context_name}'' );';                                                                                                                                                                                                                                                |
   
#### 示例
**示例一**
获取帮助信息。
```
--连接数据库。（根据实际需要替换数据库名字和端口号）
gsql -d postgres -p 8000
gsql ((GaussDB Kernel XXX.X.XXX build f521c606) compiled at 2021-09-16 14:55:22 last mr 6385 release)
Non-SSL connection (SSL connection is recommended when requiring high-security)
Type "help" for help.
--查看GaussDB支持的所有SQL语句。
gaussdb=#  \h
Available help:
  ABORT                            
  ALTER AGGREGATE
 ... ...
--查看DROP TABLE语法的参数。
gaussdb=#  \h DROP TABLE
Command:     DROP TABLE
Description: remove a table
Syntax:
DROP TABLE [ IF EXISTS ]
    { [schema.]table_name } [, ...] [ CASCADE | RESTRICT ] [ PURGE ];
--查看gsql支持的元命令。
gaussdb=#  \?
General
  \copyright             show GaussDB Kernel usage and distribution terms
  \g [FILE] or ;         execute query (and send results to file or |pipe)  
... ...
```
**示例二**
使用元命令。
```
--连接数据库。（根据实际需要替换数据库名字和端口号）
gsql -d postgres -p 8000
gsql ((GaussDB Kernel XXX.X.XXX build f521c606) compiled at 2021-09-16 14:55:22 last mr 6385 release)
Non-SSL connection (SSL connection is recommended when requiring high-security)
Type "help" for help.
--创建表。
gaussdb=# CREATE SCHEMA HR;
CREATE SCHEMA
gaussdb=# CREATE TABLE HR.areaS(area_ID NUMBER,area_NAME VARCHAR2(25));
NOTICE:  The 'DISTRIBUTE BY' clause is not specified. Using 'area_id' as the distribution column by default.
HINT:  Please use 'DISTRIBUTE BY' clause to specify suitable data distribution column.
CREATE TABLE
--查看表的定义。
gaussdb=#  \d HR.areaS
               Table "hr.areas"
  Column   |         Type          | Modifiers
-----------+-----------------------+-----------
 area_id   | numeric               |
 area_name | character varying(25) |
--向HR.areaS表插入四行数据。
gaussdb=# INSERT INTO HR.areaS (area_ID, area_NAME) VALUES (1, 'Europe');
INSERT 0 1
gaussdb=# INSERT INTO HR.areaS (area_ID, area_NAME) VALUES (2, 'Americas');
INSERT 0 1
gaussdb=# INSERT INTO HR.areaS (area_ID, area_NAME) VALUES (3, 'Asia');
INSERT 0 1
gaussdb=# INSERT INTO HR.areaS (area_ID, area_NAME) VALUES (4, 'Middle East and Africa');
INSERT 0 1
--查看表。
gaussdb=# SELECT * FROM HR.areaS;
area_id |       area_name
---------+------------------------
       4 | Middle East and Africa
       1 | Europe
       2 | Americas
       3 | Asia
(4 rows)
--用\pset命令以不同的方式显示表。
gaussdb=# \pset border 2
Border style is 2.
gaussdb=# SELECT * FROM HR.areaS;
+---------+------------------------+
| area_id |       area_name        |
+---------+------------------------+
|       4 | Middle East and Africa |
|       1 | Europe                 |
|       2 | Americas               |
|       3 | Asia                   |
+---------+------------------------+
(4 rows)
gaussdb=# \pset border 0
Border style is 0.
gaussdb=# SELECT * FROM HR.areaS;
area_id       area_name
------- ----------------------
      4 Middle East and Africa
      1 Europe
      2 Americas
      3 Asia
(4 rows)
--使用元命令。
gaussdb=# \a \t \x
Output format is unaligned.
Showing only tuples.
Expanded display is on.
gaussdb=# SELECT * FROM HR.areaS;
area_id|4
area_name|Middle East and Africa
area_id|1
area_name|Europe
area_id|2
area_name|Americas
area_id|3
area_name|Asia
gaussdb=# \a \t \x
Output format is aligned.
Tuples only is off.
Expanded display is off.
gaussdb=# SELECT * FROM HR.areaS;
area_id       area_name
------- ----------------------
      4 Middle East and Africa
      1 Europe
      2 Americas
      3 Asia
(4 rows)
gaussdb=# DROP TABLE HR.areaS;
DROP TABLE
gaussdb=# DROP SCHEMA HR;
DROP SCHEMA
```
