==========================  系统信息函数和运算符 ========================== .. container:: sect1 :name: FUNCTIONS-INFO .. container:: titlepage .. container:: .. container:: .. rubric:: 9.25. 系统信息函数和运算符 :name: 系统信息函数和运算符 :class: title `表 9.63 `__\ 展示了多个可以抽取会话和系统信息的函数。 除了本节列出的函数，还有一些与统计系统相关的函数也提供系统信息。 .. container:: table :name: FUNCTIONS-INFO-SESSION-TABLE **表 9.63. 会话信息函数** .. container:: table-contents +----------------------+----------------------+----------------------+ | 名称 | 返回类型 | 描述 | +======================+======================+======================+ | ``current_catalog`` | ``name`` | 当前数据库名（SQL | | | | 标准中称作“目录”） | +----------------------+----------------------+----------------------+ | `` | ``name`` | 当前数据库名 | | current_database()`` | | | +----------------------+----------------------+----------------------+ | ``current_query()`` | ``text`` | 当前正在 | | | | 执行的查询的文本，和 | | | | 客户端提交的一样（可 | | | | 能包含多于一个语句） | +----------------------+----------------------+----------------------+ | ``current_role`` | ``name`` | 等效 | | | | 于\ ``current_user`` | +----------------------+----------------------+----------------------+ | ``cu | ``name`` | 当前模式名 | | rrent_schema``\ [()] | | | +----------------------+----------------------+----------------------+ | ``curren | ``name[]`` | 搜索 | | t_schemas(boolean``) | | 路径中的模式名，可以 | | | | 选择是否包含隐式模式 | +----------------------+----------------------+----------------------+ | ``current_user`` | ``name`` | 当 | | | | 前执行上下文的用户名 | +----------------------+----------------------+----------------------+ | `` | ``inet`` | 远程连接的地址 | | inet_client_addr()`` | | | +----------------------+----------------------+----------------------+ | `` | ``int`` | 远程连接的端口 | | inet_client_port()`` | | | +----------------------+----------------------+----------------------+ | `` | ``inet`` | 本地连接的地址 | | inet_server_addr()`` | | | +----------------------+----------------------+----------------------+ | `` | ``int`` | 本地连接的端口 | | inet_server_port()`` | | | +----------------------+----------------------+----------------------+ | ``pg_backend_pid()`` | ``int`` | 与当前会话关 | | | | 联的服务器进程的进程 | | | | ID | +----------------------+----------------------+----------------------+ | ``pg_ | ``int[]`` | 阻塞指定服务 | | blocking_pids(int``) | | 器进程ID获得锁的进程 | | | | ID | +----------------------+----------------------+----------------------+ | ``p | ``timest | 配置载入时间 | | g_conf_load_time()`` | amp with time zone`` | | +----------------------+----------------------+----------------------+ | ``pg_curre | ``text`` | 当 | | nt_logfile([text``]) | | 前日志收集器在使用的 | | | | 主日志文件名或者所要 | | | | 求格式的日志的文件名 | +----------------------+----------------------+----------------------+ | ``p | ``oid`` | 会话的临时模式的 | | g_my_temp_schema()`` | | OID，如果没有则为 0 | +----------------------+----------------------+----------------------+ | ``pg_is_othe | ``boolean`` | 模式是另一 | | r_temp_schema(oid``) | | 个会话的临时模式吗？ | +----------------------+----------------------+----------------------+ | `` | ``boolean`` | 这个会 | | pg_jit_available()`` | | 话中JIT编译是否可用 | | | | （见\ `第 31 章 `__\ ）？如果\ | | | | `jit `__\ 被设置为假，则 | | | | 返回\ ``false``\ 。 | +----------------------+----------------------+----------------------+ | ``pg_li | ``setof text`` | 会话当 | | stening_channels()`` | | 前正在监听的频道名称 | +----------------------+----------------------+----------------------+ | ``pg_notifica | ``double`` | 异步通知队列当前 | | tion_queue_usage()`` | | 被占用的分数（0-1） | +----------------------+----------------------+----------------------+ | ``pg_postm | ``timest | 服务器启动时间 | | aster_start_time()`` | amp with time zone`` | | +----------------------+----------------------+----------------------+ | ``pg_safe_snapshot_ | ``int[]`` | 阻止指定服务器进程ID | | blocking_pids(int``) | | 获取安全快照的进程ID | +----------------------+----------------------+----------------------+ | `` | ``int`` | PostgreS | | pg_trigger_depth()`` | | QL触发器的当前嵌套层 | | | | 次（如果没有调用则为 | | | | 0，直接或间接，从 | | | | 一个触发器内部开始） | +----------------------+----------------------+----------------------+ | ``session_user`` | ``name`` | 会话用户名 | +----------------------+----------------------+----------------------+ | ``user`` | ``name`` | 等价 | | | | 于\ ``current_user`` | +----------------------+----------------------+----------------------+ | ``version()`` | ``text`` | PostgreSQL版本信息。 | | | | 机器可读的版本还可见 | | | | \ `server_version_nu | | | | m `__\ 。 | +----------------------+----------------------+----------------------+ .. note:: .. rubric:: 注意 :name: 注意 :class: title ``current_catalog``\ 、\ ``current_role``\ 、\ ``current_schema``\ 、\ ``current_user``\ 、\ ``session_user``\ 和\ ``user``\ 在SQL里有特殊的语意状态： 它们被调用时结尾不要跟着园括号（在 PostgreSQL 中，圆括号可以有选择性地被用于\ ``current_schema``\ ，但是不能和其他的一起用）。 ``session_user``\ 通常是发起当前数据库连接的用户，不过超级用户可以用\ `SET SESSION AUTHORIZATION `__\ 修改这个设置。\ ``current_user``\ 是用于权限检查的用户标识。通常， 它总是等于会话用户，但是可以被\ `SET ROLE `__\ 改变。它也会在函数执行的过程中随着属性\ ``SECURITY DEFINER``\ 的改变而改变。在 Unix 的说法里，那么会话用户是“真实用户”，而当前用户是“有效用户”。\ ``current_role``\ 以及\ ``user``\ 是\ ``current_user``\ 的同义词（SQL标准在\ ``current_role``\ 和\ ``current_user``\ 之间做了区分，但PostgreSQL不区分，因为它把用户和角色统一成了一种实体）。 ``current_schema``\ 返回在搜索路径中的第一个模式名（如果搜索路径是空则返回空值）。 如果创建表或者其它命名对象时没有声明目标模式，那么它将是被用于这些对象的模式。\ ``current_schemas(boolean)``\ 返回一个在搜索路径中出现的所有模式名的数组。布尔选项决定\ ``pg_catalog``\ 这样的隐式包含的系统模式是否包含在返回的搜索路径中。 .. note:: .. rubric:: 注意 :name: 注意-1 :class: title 搜索路径可以在运行时修改。命令是： .. code:: programlisting SET search_path TO schema [, schema, ...] ``inet_client_addr``\ 返回当前客户端的 IP 地址，\ ``inet_client_port``\ 返回它的端口号。 ``inet_server_addr``\ 返回接受当前连接的服务器的 IP 地址，而\ ``inet_server_port``\ 返回对应的端口号。如果连接是通过 Unix 域套接字进行的，那么所有这些函数都返回 NULL。 ``pg_blocking_pids``\ 返回一个进程 ID 的数组，数组中的进程中的会话阻塞了指定进程 ID 所代表的服务器进程，如果指定的服务器进程不存在或者没有被阻塞则返回空数组。如果一个进程持有与另一个进程加锁请求冲突的锁（硬锁），或者前者正在等待一个与后者加锁请求冲突的锁并且前者在该锁的等待队列中位于后者的前面（软锁），则前者会阻塞后者。在使用并行查询时，这个函数的结果总是会列出客户端可见的进程 ID（即\ ``pg_backend_pid``\ 的结果），即便实际的锁是由工作者进程所持有或者等待也是如此。这样造成的后果是，结果中可能会有很多重复的 PID。还要注意当一个预备事务持有一个冲突锁时，这个函数的结果中它将被表示为一个为零的进程 ID。对这个函数的频繁调用可能对数据库性能有一些影响，因为它需要短时间地独占访问锁管理器的共享状态。 ``pg_conf_load_time``\ 返回服务器配置文件最近被载入的\ ``timestamp with time zone``\ （如果当前会话在那时就已经存在，这个值将是该会话自己重新读取配置文件的时间，因此在不同的会话中这个读数会有一点变化。如果不是这样，这个值就是 postmaster 进程重读配置文件的时间）。 ``pg_current_logfile``\ 以\ ``text``\ 类型返回当前被日志收集器使用的日志文件的路径。该路径包括\ `log_directory `__\ 目录和日志文件名。日志收集必须被启用，否则返回值为\ ``NULL``\ 。当多个日志文件存在并且每一个都有不同的格式时，不带参数调用\ ``pg_current_logfile``\ 会返回这样的文件的路径：在所有的文件中，没有任何文件的格式在列表stderr、csvlog中排在这个文件的格式前面。如果没有任何日志文件有上述格式，则返回\ ``NULL``\ 。要请求一种特定的文件格式，可以以\ ``text``\ 将csvlog或者stderr作为可选参数的值。当所请求的日志格式不是已配置的\ `log_destination `__\ 时，会返回\ ``NULL``\ 。\ ``pg_current_logfile``\ 反映了\ ``current_logfiles``\ 文件的内容。 ``pg_my_temp_schema``\ 返回当前会话临时模式的 OID，如果没有使用临时模式（因为它没有创建任何临时表）则返回零。如果给定的 OID 是另一个会话的临时模式的 OID，则\ ``pg_is_other_temp_schema``\ 返回真（这是有用的，例如，要将其他会话的临时表从一个目录显示中排除）。 ``pg_listening_channels``\ 返回当前会话正在监听的异步通知频道的名称的集合。\ ``pg_notification_queue_usage``\ 返回等待处理的通知占可用的通知空间的比例，它是一个 0-1 范围内的\ ``double``\ 值。详见\ `LISTEN `__\ 和\ `NOTIFY `__\ 。 ``pg_postmaster_start_time``\ 返回服务器启动的\ ``timestamp with time zone``\ 。 ``pg_safe_snapshot_blocking_pids``\ 一个进程ID的数组，它们代表阻止指定进程ID对应的服务器进程获取安全快照的会话，如果没有这类服务器进程或者它没有被阻塞，则会返回一个空数组。一个运行着\ ``SERIALIZABLE``\ 事务的会话会阻止\ ``SERIALIZABLE READ ONLY DEFERRABLE``\ 事务获取快照，直到后者确定避免拿到任何谓词锁是安全的。频繁调用这个函数可能会对数据库性能产生一些影响，因为它需要短时间访问谓词锁管理器的共享状态。 ``version``\ 返回一个描述PostgreSQL服务器版本的字符串。你也可以从\ `server_version `__\ 或者一个机器可读的版本\ `server_version_num `__\ 得到这个信息。软件开发者应该使用\ ``server_version_num``\ （从 8.2 开始可用）或者 ```PQserverVersion`` `__ ，而不必解析文本形式的版本。 `表 9.64 `__\ 列出那些允许用户编程查询对象访问权限的函数。参阅\ `第 5.7 节 `__\ 获取更多有关权限的信息。 .. container:: table :name: FUNCTIONS-INFO-ACCESS-TABLE **表 9.64. 访问权限查询函数** .. container:: table-contents +--------------------------+-------------+--------------------------+ | 名称 | 返回类型 | 描述 | +==========================+=============+==========================+ | ``has_any_column_p | ``boolean`` | 用户 | | rivilege``\ (*``user``*, | | 有没有表中任意列上的权限 | | *``table``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_any_column_pr | ``boolean`` | 当前用户 | | ivilege``\ (*``table``*, | | 有没有表中任意列上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_column_p | ``boolean`` | 用户有没有列的权限 | | rivilege``\ (*``user``*, | | | | *``table``*, | | | | *``column``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_column_pr | ``boolean`` | 当前用户有没有列的权限 | | ivilege``\ (*``table``*, | | | | *``column``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_database_p | ``boolean`` | 用户有没有数据库的权限 | | rivilege``\ (*``user``*, | | | | *``database``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_database_privi | ``boolean`` | 当 | | lege``\ (*``database``*, | | 前用户有没有数据库的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``ha | ``boolean`` | 用户有没 | | s_foreign_data_wrapper_p | | 有外部数据包装器上的权限 | | rivilege``\ (*``user``*, | | | | *``fdw``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``h | ``boolean`` | 当前用户有没 | | as_foreign_data_wrapper_ | | 有外部数据包装器上的权限 | | privilege``\ (*``fdw``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_function_p | ``boolean`` | 用户有没有函数上的权限 | | rivilege``\ (*``user``*, | | | | *``function``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_function_privi | ``boolean`` | 当 | | lege``\ (*``function``*, | | 前用户有没有函数上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_language_p | ``boolean`` | 用户有没有语言上的权限 | | rivilege``\ (*``user``*, | | | | *``language``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_language_privi | ``boolean`` | 当 | | lege``\ (*``language``*, | | 前用户有没有语言上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_schema_p | ``boolean`` | 用户有没有模式上的权限 | | rivilege``\ (*``user``*, | | | | *``schema``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_schema_pri | ``boolean`` | 当 | | vilege``\ (*``schema``*, | | 前用户有没有模式上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_sequence_p | ``boolean`` | 用户有没有序列上的权限 | | rivilege``\ (*``user``*, | | | | *``sequence``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_sequence_privi | ``boolean`` | 当 | | lege``\ (*``sequence``*, | | 前用户有没有序列上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_server_p | ``boolean`` | 用户 | | rivilege``\ (*``user``*, | | 有没有外部服务器上的权限 | | *``server``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_server_pri | ``boolean`` | 当前用户 | | vilege``\ (*``server``*, | | 有没有外部服务器上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_table_p | ``boolean`` | 用户有没有表上的权限 | | rivilege``\ (*``user``*, | | | | *``table``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_table_pr | ``boolean`` | 当前用户有没有表上的权限 | | ivilege``\ (*``table``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_tablespace_p | ``boolean`` | 用户有没有表空间上的权限 | | rivilege``\ (*``user``*, | | | | *``tablespace``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_tablespace_privile | ``boolean`` | 当前 | | ge``\ (*``tablespace``*, | | 用户有没有表空间上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_type_p | ``boolean`` | 用户有没有类型的特权 | | rivilege``\ (*``user``*, | | | | *``type``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``has_type_p | ``boolean`` | 当前用户有没有类型的特权 | | rivilege``\ (*``type``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``pg_ | ``boolean`` | 用户有没有角色上的权限 | | has_role``\ (*``user``*, | | | | *``role``*, | | | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``pg_ | ``boolean`` | 当 | | has_role``\ (*``role``*, | | 前用户有没有角色上的权限 | | *``privilege``*) | | | +--------------------------+-------------+--------------------------+ | ``row_security | ``boolean`` | 当前用户是 | | _active``\ (*``table``*) | | 否在表上开启了行级安全性 | +--------------------------+-------------+--------------------------+ ``has_table_privilege``\ 判断一个用户是否可以用某种特定的方式访问一个表。 该用户可以通过名字或者 OID （\ ``pg_authid.oid``\ ） 来指定，也可以用\ ``public``\ 表示 PUBLIC 伪角色。如果省略该参数，则使用\ ``current_user``\ 。 该表可以通过名字或者 OID 指定（因此，实际上有六种 ``has_table_privilege``\ 的变体，我们可以通过它们的参数数目和类型来区分它们） 。如果用名字指定，那么在必要时该名字可以是模式限定的。 所希望的权限类型是用一个文本串来指定的，它必须是下面的几个值之一： ``SELECT``\ 、\ ``INSERT``\ 、\ ``UPDATE``\ 、\ ``DELETE``\ 、\ ``TRUNCATE``\ 、\ ``REFERENCES``\ 或\ ``TRIGGER``\ 。\ ``WITH GRANT OPTION``\ 可以被选择增加到一个权限类型来测试是否该权限是使用转授选项得到。另外，可以使用逗号分隔来列出多个权限类型，在这种情况下只要具有其中之一的权限则结果为\ ``真``\ （权限字符串的大小写并不重要，可以在权限名称之间出现额外的空白，但是在权限名内部不能有空白）。一些例子： .. code:: programlisting SELECT has_table_privilege('myschema.mytable', 'select'); SELECT has_table_privilege('joe', 'mytable', 'INSERT, SELECT WITH GRANT OPTION'); ``has_sequence_privilege``\ 检查一个用户是否能以某种特定方式访问一个序列。它的参数可能性和\ ``has_table_privilege``\ 相似。所希望测试的访问权限类型必须是下列之一：\ ``USAGE``\ 、\ ``SELECT``\ 或\ ``UPDATE``\ 。 ``has_any_column_privilege``\ 检查一个用户是否能以特定方式访问一个表的任意列。其参数可能性和\ ``has_table_privilege``\ 类似，除了所希望的访问权限类型必须是下面值的某种组合：\ ``SELECT``\ 、\ ``INSERT``\ 、\ ``UPDATE``\ 或\ ``REFERENCES``\ 。注意在表层面上具有这些权限的任意一个都会隐式地把它授权给表中的每一列，因此如果\ ``has_table_privilege``\ 对同样的参数返回真则\ ``has_any_column_privilege``\ 将总是返回\ ``真``\ 。但是如果在至少一列上有一个该权限的列级授权，\ ``has_any_column_privilege``\ 也会成功。 ``has_column_privilege``\ 检查一个用户是否能以特定方式访问一个列。它的参数可能性与\ ``has_table_privilege``\ 类似，并且列还可以使用名字或者属性号来指定。希望的访问权限类型必须是下列值的某种组合：\ ``SELECT``\ 、\ ``INSERT``\ 、\ ``UPDATE``\ 或\ ``REFERENCES``\ 。注意在表级别上具有这些权限中的任意一种将会隐式地把它授予给表上的每一列。 ``has_database_privilege``\ 检查一个用户是否能以特定方式访问一个数据库。它的参数可能性类似 ``has_table_privilege``\ 。希望的访问权限类型必须是以下值的某种组合：\ ``CREATE``\ 、\ ``CONNECT``\ 、\ ``TEMPORARY``\ 或\ ``TEMP``\ （等价于\ ``TEMPORARY``\ ）。 ``has_function_privilege``\ 检查一个用户是否能以特定方式访问一个函数。其参数可能性类似\ ``has_table_privilege``\ 。在用一个文本串而不是 OID 指定一个函数时，允许的输入和\ ``regprocedure``\ 数据类型一样（参阅 `第 8.19 节 `__\ ）。希望的访问权限类型必须是\ ``EXECUTE``\ 。一个例子： .. code:: programlisting SELECT has_function_privilege('joeuser', 'myfunc(int, text)', 'execute'); ``has_foreign_data_wrapper_privilege``\ 检查一个用户是否能以特定方式访问一个外部数据包装器。它的参数可能性类似于\ ``has_table_privilege``\ 。希望的访问权限类型必须是\ ``USAGE``\ 。 ``has_language_privilege``\ 检查一个用户是否可以以某种特定的方式访问一个过程语言。 其参数可能性类似 ``has_table_privilege``\ 。希望的访问权限类型必须是\ ``USAGE``\ 。 ``has_schema_privilege``\ 检查一个用户是否可以以某种特定的方式访问一个模式。 其参数可能性类似 ``has_table_privilege``\ 。希望的访问权限类型必须是\ ``CREATE``\ 或\ ``USAGE``\ 。 ``has_server_privilege``\ 检查一个用户是否可以以某种特定的方式访问一个外部服务器。 其参数可能性类似 ``has_table_privilege``\ 。希望的访问权限类型必须是\ ``USAGE``\ 。 ``has_tablespace_privilege``\ 检查一个用户是否可以以某种特定的方式访问一个表空间。其参数可能性类似 ``has_table_privilege``\ 。希望的访问权限类型必须是\ ``CREATE``\ 。 ``has_type_privilege``\ 检查一个用户是否能以特定的方式访问一种类型。其参数的可能性类同于\ ``has_table_privilege``\ 。在用字符串而不是 OID 指定类型时，允许的输入和\ ``regtype``\ 数据类型相同（见\ `第 8.19 节 `__\ ）。期望的访问特权类型必须等于\ ``USAGE``\ 。 ``pg_has_role``\ 检查一个用户是否可以以某种特定的方式访问一个角色。其参数可能性类似 ``has_table_privilege``\ ，除了\ ``public``\ 不能被允许作为一个用户名。希望的访问权限类型必须是下列值的某种组合：\ ``MEMBER``\ 或\ ``USAGE``\ 。\ ``MEMBER``\ 表示该角色中的直接或间接成员关系（即使用\ ``SET ROLE``\ 的权力），而\ ``USAGE``\ 表示不做\ ``SET ROLE``\ 的情况下该角色的权限是否立即可用。 ``row_security_active``\ 检查在 ``current_user``\ 的上下文和环境中是否为指定的 表激活了行级安全性。表可以用名称或者 OID 指定。 `表 9.66 `__ 显示了\ ``aclitem``\ 类型的可用操作符，它是访问权限的目录表示。 有关如何读取访问权限值的信息，请参阅 `第 5.7 节 `__\ 。 .. container:: table :name: FUNCTIONS-ACLITEM-OP-TABLE **表 9.65. ``aclitem`` Operators** .. container:: table-contents +--------+----------+---------------------------------------+-------+ | 操作符 | 描述 | 例子 | 结果 | +========+==========+=======================================+=======+ | ``=`` | equal | ``'calvin=r*w/hobbes'::acli | ``f`` | | | | tem = 'calvin=r*w*/hobbes'::aclitem`` | | +--------+----------+---------------------------------------+-------+ | ``@>`` | 包含元素 | ``'{calvin=r*w/ | ``t`` | | | | hobbes,hobbes=r*w*/postgres}'::aclite | | | | | m[] @> 'calvin=r*w/hobbes'::aclitem`` | | +--------+----------+---------------------------------------+-------+ | ``~`` | 包含元素 | ``'{calvin=r*w | ``t`` | | | | /hobbes,hobbes=r*w*/postgres}'::aclit | | | | | em[] ~ 'calvin=r*w/hobbes'::aclitem`` | | +--------+----------+---------------------------------------+-------+ `表 9.66 `__ 显示了一些额外的函数来管理\ ``aclitem``\ 类型。 .. container:: table :name: FUNCTIONS-ACLITEM-FN-TABLE **表 9.66. ``aclitem`` Functions** .. container:: table-contents +------------------------+------------------+------------------------+ | 名称 | 返回类型 | 描述 | +========================+==================+========================+ | ``acld | ``aclitem[]`` | 获取 | | efault``\ (*``type``*, | | 属于\ *``ownerId``*\ | | *``ownerId``*) | | 的对象的默认访问权限。 | +------------------------+------------------+------------------------+ | ``aclexplod | ``setof record`` | 获取 ``aclitem`` | | e``\ (*``aclitem[]``*) | | 数组为元组 | +------------------------+------------------+------------------------+ | ``makeacli | ``aclitem`` | 从输入中建立 | | tem``\ (*``grantee``*, | | 一个\ ``aclitem``\ 。 | | *``grantor``*, | | | | *``privilege``*, | | | | *``grantable``*) | | | +------------------------+------------------+------------------------+ ``acldefault``\ 返回属于角色\ *``ownerId``*\ 的\ *``type``*\ 类型的对象的内置默认访问权限。 这些代表了当对象的ACL条目为空时将被假定的访问权限。 (默认的访问权限在\ `第 5.7 节 `__\ 中描述了)。 *``type``* 参数是一个 ``CHAR``: 'c' for ``COLUMN``, 'r' for ``TABLE`` 和类表对象, 's' for ``SEQUENCE``, 'd' for ``DATABASE``, 'f' for ``FUNCTION`` 或者 ``PROCEDURE``, 'l' for ``LANGUAGE``, 'L' for ``LARGE OBJECT``, 'n' for ``SCHEMA``, 't' for ``TABLESPACE``, 'F' for ``FOREIGN DATA WRAPPER``, 'S' for ``FOREIGN SERVER``, 'T' for ``TYPE`` 或者 ``DOMAIN``. ``aclexplode``\ 返回一个\ ``aclitem``\ 数组作为行集。输出的列是grantor ``oid``, grantee ``oid`` (``0`` for ``PUBLIC``), 被授权为 ``text`` (``SELECT``, ...) 以及权限是否可以被授予\ ``boolean``\ 。\ ``makeaclitem``\ 执行反向操作。 `表 9.67 `__\ 展示了决定是否一个特定对象在当前模式搜索路径中\ *可见*\ 的函数。例如，如果一个表所在的模式在当前搜索路径中并且在它之前没有出现过相同的名字，这个表就被说是可见的。这等价于在语句中表可以被用名称引用但不加显式的模式限定。要列出所有可见表的名字： .. code:: programlisting SELECT relname FROM pg_class WHERE pg_table_is_visible(oid); .. container:: table :name: FUNCTIONS-INFO-SCHEMA-TABLE **表 9.67. 模式可见性查询函数** .. container:: table-contents +--------------------------+-------------+--------------------------+ | 名称 | 返回类型 | 描述 | +==========================+=============+==========================+ | ``pg_collation_is_ | ``boolean`` | 排序 | | visible(collation_oid``) | | 规则在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_conversion_is_v | ``boolean`` | 转换在搜索路径中可见吗？ | | isible(conversion_oid``) | | | +--------------------------+-------------+--------------------------+ | ``pg_function_is | ``boolean`` | 函数在搜索路径中可见吗？ | | _visible(function_oid``) | | | +--------------------------+-------------+--------------------------+ | ``pg_opclass_i | ``boolean`` | 操作 | | s_visible(opclass_oid``) | | 符类在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_operator_is | ``boolean`` | 操 | | _visible(operator_oid``) | | 作符在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_opfamily_i | ``boolean`` | 操作 | | s_visible(opclass_oid``) | | 符族在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_statistics_ob | ``boolean`` | 是 | | j_is_visible(stat_oid``) | | 搜索路径中的统计信息对象 | +--------------------------+-------------+--------------------------+ | ``pg_table | ``boolean`` | 表在搜索路径中可见吗？ | | _is_visible(table_oid``) | | | +--------------------------+-------------+--------------------------+ | ``pg_ts_config_ | ``boolean`` | 文本搜索 | | is_visible(config_oid``) | | 配置在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_ts_dic | ``boolean`` | 文本搜索 | | t_is_visible(dict_oid``) | | 字典在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_ts_parser_ | ``boolean`` | 文本搜索解 | | is_visible(parser_oid``) | | 析器在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_ts_template_is | ``boolean`` | 文本搜索 | | _visible(template_oid``) | | 模板在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ | ``pg_typ | ``boolean`` | 类型（或 | | e_is_visible(type_oid``) | | 域）在搜索路径中可见吗？ | +--------------------------+-------------+--------------------------+ 每一个函数对一种数据库对象执行可见性检查。注意\ ``pg_table_is_visible``\ 也可被用于视图、物化视图、索引、序列和外部表，\ ``pg_function_is_visible``\ 也能被用于过程和聚集，\ ``pg_type_is_visible``\ 也可以被用于域。对于函数和操作符，如果在路径中更早的地方没有出现具有相同名称\ *和参数数据类型*\ 的对象，该对象在搜索路径中是可见的。对于操作符类，名称和相关的索引访问方法都要考虑。 所有这些函数都要求用对象 OID 来标识将被检查的对象。如果你想用名称来测试一个对象，使用 OID 别名类型（\ ``regclass``\ 、\ ``regtype``\ 、\ ``regprocedure``\ 、\ ``regoperator``\ 、\ ``regconfig``\ 或\ ``regdictionary``\ ）将会很方便。例如： .. code:: programlisting SELECT pg_type_is_visible('myschema.widget'::regtype); 注意以这种方式测试一个非模式限定的类型名没什么意义 — 如果该名称完全能被识别，它必须是可见的。 `表 9.68 `__\ 列出了从系统目录抽取信息的函数。 .. container:: table :name: FUNCTIONS-INFO-CATALOG-TABLE **表 9.68. 系统目录信息函数** .. container:: table-contents +------------------------+------------------+------------------------+ | 名称 | 返回类型 | 描述 | +========================+==================+========================+ | ``f | ``text`` | 获得一个数据类型的 SQL | | ormat_type(type_oid``, | | 名字 | | *``typemod``*) | | | +------------------------+------------------+------------------------+ | ``pg_get_constrain | ``text`` | 获得一个约束的定义 | | tdef(constraint_oid``) | | | +------------------------+------------------+------------------------+ | ``pg_get_constrain | ``text`` | 获得一个约束的定义 | | tdef(constraint_oid``, | | | | *``pretty_bool``*) | | | +------------------------+------------------+------------------------+ | ``pg_ge | ``text`` | 反编译一个表达式的内 | | t_expr(pg_node_tree``, | | 部形式，假定其中的任何 | | *``relation_oid``*) | | Var | | | | 指向 | | | | 由第二个参数指示的关系 | +------------------------+------------------+------------------------+ | ``pg_ge | ``text`` | 反编译一个表达式的内 | | t_expr(pg_node_tree``, | | 部形式，假定其中的任何 | | *``relation_oid``*, | | Var | | *``pretty_bool``*) | | 指向 | | | | 由第二个参数指示的关系 | +------------------------+------------------+------------------------+ | ``pg_get_f | ``text`` | 获 | | unctiondef(func_oid``) | | 得一个函数或过程的定义 | +------------------------+------------------+------------------------+ | ``pg_get_function | ``text`` | 获 | | _arguments(func_oid``) | | 得一个函数或过程定义的 | | | | 参数列表（带有默认值） | +------------------------+------------------+------------------------+ | ``pg | ``text`` | 获 | | _get_function_identity | | 得标识一个函数或过程的 | | _arguments(func_oid``) | | 参数列表（不带默认值） | +------------------------+------------------+------------------------+ | ``pg_get_funct | ``text`` | 获 | | ion_result(func_oid``) | | 得函数的\ ``RETURNS`` | | | | \ 子句（对过程返回空） | +------------------------+------------------+------------------------+ | ``pg_get | ``text`` | 获得索引的\ | | _indexdef(index_oid``) | | ``CREATE INDEX``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_get | ``text`` | 获得 | | _indexdef(index_oid``, | | 索引的\ ``CREATE INDE | | *``column_no``*, | | X``\ 命令，或者当\ *`` | | *``pretty_bool``*) | | column_no``*\ 为非零时 | | | | 只得到一个索引列的定义 | +------------------------+------------------+------------------------+ | ``pg_get_keywords()`` | ``setof record`` | 获得 SQL | | | | 关键字的列表及其分类 | +------------------------+------------------+------------------------+ | ``pg_g | ``text`` | 获得规则的\ | | et_ruledef(rule_oid``) | | ``CREATE RULE``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_g | ``text`` | 获得规则的\ | | et_ruledef(rule_oid``, | | ``CREATE RULE``\ 命令 | | *``pretty_bool``*) | | | +------------------------+------------------+------------------------+ | ``pg_get_serial_ | ``text`` | 获得一个序列列或 | | sequence(table_name``, | | 标识列使用的序列的名称 | | *``column_name``*) | | | +------------------------+------------------+------------------------+ | ``pg_get_statistic | ``text`` | 为扩展的统 | | sobjdef(statobj_oid``) | | 计信息对象得到\ ``CRE | | | | ATE STATISTICS``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_get_triggerdef` | ``text`` | 获得触发器 | | `\ (*``trigger_oid``*) | | 的\ ``CREATE [ CONSTR | | | | AINT ] TRIGGER``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_get_triggerdef` | ``text`` | 获得触发器 | | `\ (*``trigger_oid``*, | | 的\ ``CREATE [ CONSTR | | *``pretty_bool``*) | | AINT ] TRIGGER``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_ge | ``name`` | 获得给定 OID | | t_userbyid(role_oid``) | | 指定的角色名 | +------------------------+------------------+------------------------+ | ``pg_ge | ``text`` | 获得视图或物化 | | t_viewdef(view_name``) | | 视图的底层\ ``SELECT`` | | | | \ 命令（\ *已废弃*\ ） | +------------------------+------------------+------------------------+ | ``pg_ge | ``text`` | 获得视图或物化 | | t_viewdef(view_name``, | | 视图的底层\ ``SELECT`` | | *``pretty_bool``*) | | \ 命令（\ *已废弃*\ ） | +------------------------+------------------+------------------------+ | ``pg_g | ``text`` | 获得视图或物化视图的 | | et_viewdef(view_oid``) | | 底层\ ``SELECT``\ 命令 | +------------------------+------------------+------------------------+ | ``pg_g | ``text`` | 获得视图或物化视图的 | | et_viewdef(view_oid``, | | 底层\ ``SELECT``\ 命令 | | *``pretty_bool``*) | | | +------------------------+------------------+------------------------+ | ``pg_g | ``text`` | 获得视图或物化视图的底 | | et_viewdef(view_oid``, | | 层\ ``SELECT``\ 命令； | | *``wrap_column_int``*) | | 带域的行被包装成指定的 | | | | 列数，并隐含了优质打印 | +------------------------+------------------+------------------------+ | ``pg_index_column_has | ``boolean`` | 测试一个 | | _property(index_oid``, | | 索引列是否有指定的性质 | | *``column_no``*, | | | | *``prop_name``*) | | | +------------------------+------------------+------------------------+ | ``pg_index_has | ``boolean`` | 测试一 | | _property(index_oid``, | | 个索引是否有指定的性质 | | *``prop_name``*) | | | +------------------------+------------------+------------------------+ | ``pg_indexam_ | ``boolean`` | 测试一个索引访 | | has_property(am_oid``, | | 问方法是否有指定的性质 | | *``prop_name``*) | | | +------------------------+------------------+------------------------+ | ``pg_options_ | ``setof record`` | 获得存储 | | to_table(reloptions``) | | 选项的名称/值对的集合 | +------------------------+------------------+------------------------+ | ``pg_tablespace_datab | ``setof oid`` | 获得在该表 | | ases(tablespace_oid``) | | 空间中有对象的数据库的 | | | | OID 的集合 | +------------------------+------------------+------------------------+ | ``pg_tablespace_loca | ``text`` | 获得这个表空 | | tion(tablespace_oid``) | | 间所在的文件系统的路径 | +------------------------+------------------+------------------------+ | ``pg_typeof(any``) | ``regtype`` | 获得任意值的数据类型 | +------------------------+------------------+------------------------+ | ` | ``text`` | 获得该参数的排序规则 | | `collation for (any``) | | | +------------------------+------------------+------------------------+ | ``t | ``regclass`` | 得到指定关系的 OID | | o_regclass(rel_name``) | | | +------------------------+------------------+------------------------+ | ``t | ``regproc`` | 得到指定函数的 OID | | o_regproc(func_name``) | | | +------------------------+------------------+------------------------+ | ``to_reg | ``regprocedure`` | 得到指定函数的 OID | | procedure(func_name``) | | | +------------------------+------------------+------------------------+ | ``to_re | ``regoper`` | 得到指定操作符的 OID | | goper(operator_name``) | | | +------------------------+------------------+------------------------+ | ``to_regope | ``regoperator`` | 得到指定操作符的 OID | | rator(operator_name``) | | | +------------------------+------------------+------------------------+ | ``t | ``regtype`` | 得到指定类型的 OID | | o_regtype(type_name``) | | | +------------------------+------------------+------------------------+ | ``to_regna | ``regnamespace`` | 得到指定模式的 OID | | mespace(schema_name``) | | | +------------------------+------------------+------------------------+ | ``t | ``regrole`` | 得到指定角色的 OID | | o_regrole(role_name``) | | | +------------------------+------------------+------------------------+ ``format_type``\ 返回一个数据类型的 SQL 名称，它由它的类型 OID 标识并且可能是一个类型修饰符。如果不知道相关的修饰符，则为类型修饰符传递 NULL。 ``pg_get_keywords``\ 返回一组记录描述服务器识别的 SQL 关键字。\ ``word``\ 列包含关键字。\ ``catcode``\ 列包含一个分类码：\ ``U``\ 为未被预定，\ ``C`` 为列名，\ ``T``\ 类型或函数名，\ ``R``\ 为预留。\ ``catdesc``\ 列包含一个可能本地化的描述分类的字符串。 ``pg_get_constraintdef``\ 、\ ``pg_get_indexdef``\ 、\ ``pg_get_ruledef``\ 、\ ``pg_get_statisticsobjdef``\ 和\ ``pg_get_triggerdef``\ 分别重建一个约束、索引、规则、扩展统计对象或触发器的创建命令（注意这是一个反编译的重构，而不是命令的原始文本）。\ ``pg_get_expr``\ 反编译一个表达式的内部形式，例如一个列的默认值。在检查系统目录内容时有用。如果表达式可能包含 Var，在第二个参数中指定它们引用的关系的 OID；如果不会出现 Var，第二个参数设置为 0 即可。\ ``pg_get_viewdef``\ 重构定义一个视图的\ ``SELECT``\ 查询。这些函数的大部分都有两种变体，一种可以可选地“优质打印”结果。优质打印的格式可读性更强，但是默认格式更可能被未来版本的PostgreSQL以相同的方式解释。在转出目的中避免使用优质打印输出。为优质打印参数传递\ ``假``\ 将得到和不带该参数的变体相同的结果。 ``pg_get_functiondef``\ 为一个函数返回一个完整的\ ``CREATE OR REPLACE FUNCTION``\ 语句。\ ``pg_get_function_arguments``\ 返回一个函数的参数列表，形式按照它们出现在\ ``CREATE FUNCTION``\ 中的那样。\ ``pg_get_function_result``\ 类似地返回函数的合适的\ ``RETURNS``\ 子句。\ ``pg_get_function_identity_arguments``\ 返回标识一个函数必要的参数列表，形式和它们出现在\ ``ALTER FUNCTION``\ 中的一样。这种形式忽略默认值。 ``pg_get_serial_sequence``\ 返回与一个列相关联的序列的名称，如果与列相关联的序列则返回 NULL。如果该列是一个标识列，相关联的序列是为该标识列内部创建的序列。对于使用序列类型之一（\ ``serial``\ 、\ ``smallserial``\ 、\ ``bigserial``\ ）创建的列，它是为那个序列列定义创建的序列。在后一种情况中，这种关联可以用\ ``ALTER SEQUENCE OWNED BY``\ 修改或者移除（该函数可能应该已经被\ ``pg_get_owned_sequence``\ 调用，它当前的名称反映了它通常被\ ``serial``\ 或\ ``bigserial``\ 列使用）。第一个输入参数是一个带可选模式的表名，第二个参数是一个列名。因为第一个参数可能是一个模式和表，它不能按照一个双引号包围的标识符来对待，意味着它默认情况下是小写的。而第二个参数只是一个列名，将被当作一个双引号包围的来处理并且会保留其大小写。函数返回的值会被适当地格式化以便传递给序列函数（参见\ `第 9.16 节 `__\ ）。一种典型的用法是为标识列或者序列列读取当前值，例如： .. code:: programlisting SELECT currval(pg_get_serial_sequence('sometable', 'id')); ``pg_get_userbyid``\ 抽取给定 OID 的角色的名称。 ``pg_index_column_has_property``\ 、\ ``pg_index_has_property``\ 和\ ``pg_indexam_has_property``\ 返回指定的索引列、索引或者索引访问方法是否具有指定性质。如果性质的名称找不到或者不适用于特定的对象，亦或者 OID 或者列号不表示合法的对象，则返回\ ``NULL``\ 。列的性质可参见\ `表 9.69 `__\ ，索引的性质可参见\ `表 9.70 `__\ ，访问方法的性质可参见\ `表 9.71 `__\ （注意扩展访问方法可以为其索引定义额外的性质）。 .. container:: table :name: FUNCTIONS-INFO-INDEX-COLUMN-PROPS **表 9.69. 索引列属性** .. container:: table-contents +------------------------+--------------------------------------------+ | 名称 | 描述 | +========================+============================================+ | ``asc`` | 在向前扫描时列是按照升序排列吗？ | +------------------------+--------------------------------------------+ | ``desc`` | 在向前扫描时列是按照降序排列吗？ | +------------------------+--------------------------------------------+ | ``nulls_first`` | 在向前扫描时列排序会把空值排在前面吗？ | +------------------------+--------------------------------------------+ | ``nulls_last`` | 在向前扫描时列排序会把空值排在最后吗？ | +------------------------+--------------------------------------------+ | ``orderable`` | 列具有已定义的排序顺序吗？ | +------------------------+--------------------------------------------+ | ``distance_orderable`` | 列能否通过一个“distance”操作符（例如\ ``O | | | RDER BY col <-> constant``\ ）有序地扫描？ | +------------------------+--------------------------------------------+ | ``returnable`` | 列值是否可以通过一次只用索引扫描返回？ | +------------------------+--------------------------------------------+ | ``search_array`` | 列 | | | 是否天然支持\ ``col = ANY(array)``\ 搜索？ | +------------------------+--------------------------------------------+ | ``search_nulls`` | 列是否支持 | | | \ ``IS NULL``\ 和\ ``IS NOT NULL``\ 搜索？ | +------------------------+--------------------------------------------+ .. container:: table :name: FUNCTIONS-INFO-INDEX-PROPS **表 9.70. 索引性质** .. container:: table-contents +-------------------+-------------------------------------------------+ | 名称 | 描述 | +===================+=================================================+ | ``clusterable`` | 索引是否可以用于\ ``CLUSTER``\ 命令？ | +-------------------+-------------------------------------------------+ | ``index_scan`` | 索引是否支持普通扫描（非位图）？ | +-------------------+-------------------------------------------------+ | ``bitmap_scan`` | 索引是否支持位图扫描？ | +-------------------+-------------------------------------------------+ | ``backward_scan`` | 在扫描中扫描方向能否被更改（为了 | | | 支持游标上无需物化的\ ``FETCH BACKWARD``\ ）？ | +-------------------+-------------------------------------------------+ .. container:: table :name: FUNCTIONS-INFO-INDEXAM-PROPS **表 9.71. 索引访问方法性质** .. container:: table-contents +-------------------+-------------------------------------------------+ | 名称 | 描述 | +===================+=================================================+ | ``can_order`` | 访问方法是否支持\ ``ASC``\ 、\ ``D | | | ESC``\ 以及\ ``CREATE INDEX``\ 中的有关关键词？ | +-------------------+-------------------------------------------------+ | ``can_unique`` | 访问方法是否支持唯一索引？ | +-------------------+-------------------------------------------------+ | ``can_multi_col`` | 访问方法是否支持多列索引？ | +-------------------+-------------------------------------------------+ | ``can_exclude`` | 访问方法是否支持排除约束？ | +-------------------+-------------------------------------------------+ | ``can_include`` | 访问方法是否 | | | 支持\ ``CREATE INDEX``\ 的\ ``INCLUDE``\ 子句？ | +-------------------+-------------------------------------------------+ 当传入\ ``pg_class``.\ ``reloptions``\ 或\ ``pg_attribute``.\ ``attoptions``\ 时，\ ``pg_options_to_table``\ 返回存储选项名称/值对（\ *``option_name``*/*``option_value``*\ ）的集合。 ``pg_tablespace_databases``\ 允许一个表空间被检查。它返回一组数据库的 OID，这些数据库都有对象存储在该表空间中。如果这个函数返回任何行，则该表空间为非空并且不能被删除。为了显示该表空间中的指定对象，你将需要连接到\ ``pg_tablespace_databases``\ 标识的数据库并且查询它们的\ ``pg_class``\ 目录。 ``pg_typeof``\ 返回传递给它的值的数据类型的 OID。这在检修或者动态构建 SQL 查询时有用。函数被声明为返回\ ``regtype``\ ，它是一个 OID 别名类型（见\ `第 8.19 节 `__\ ）；这表明它和一个用于比较目的的 OID 相同，但是作为一个类型名称显示。例如： .. code:: programlisting SELECT pg_typeof(33); pg_typeof ----------- integer (1 row) SELECT typlen FROM pg_type WHERE oid = pg_typeof(33); typlen -------- 4 (1 row) 表达式\ ``collation for``\ 返回传递给它的值的排序规则。例子： .. code:: programlisting SELECT collation for (description) FROM pg_description LIMIT 1; pg_collation_for ------------------ "default" (1 row) SELECT collation for ('foo' COLLATE "de_DE"); pg_collation_for ------------------ "de_DE" (1 row) 值可能被加上引号并且变成模式限定的。如果从参数表达式得不到排序规则，则返回一个空值。如果参数不是一个可排序的数据类型，则抛出一个错误。 ``to_regclass``\ 、\ ``to_regproc``\ 、\ ``to_regprocedure``, ``to_regoper``\ 、\ ``to_regoperator``\ 、\ ``to_regtype``\ 、\ ``to_regnamespace``\ 和\ ``to_regrole``\ 函数把关系、函数、操作符、类型、模式和角色的名称（以\ ``text``\ 给出）分别转换成、\ ``regclass``\ 、\ ``regproc``\ 、\ ``regprocedure``\ 、\ ``regoper``\ 、\ ``regoperator``\ 、\ ``regtype``\ 、\ ``regnamespace``\ 和\ ``regrole``\ 对象。这些函数与 text 转换的不同在于它们不接受数字 OID，并且在名称无法找到时不会抛出错误而是返回空。对于\ ``to_regproc``\ 和\ ``to_regoper``\ ，如果给定名称匹配多个对象时返回空。 `表 9.72 `__\ 列出了与数据库对象 标识和定位有关的函数。 .. container:: table :name: FUNCTIONS-INFO-OBJECT-TABLE **表 9.72. 对象信息和定位函数** .. container:: table-contents +----------------------+----------------------+----------------------+ | 名称 | 返回类型 | 描述 | +======================+======================+======================+ | ``pg_describe_ | ``text`` | 得到 | | object(catalog_id``, | | 一个数据库对象的描述 | | *``object_id``*, | | | | *``object_sub_id``*) | | | +----------------------+----------------------+----------------------+ | ``pg_identify | *``type``* ``text``, | 得到 | | _object(catalog_id`` | *``schema``* | 一个数据库对象的标识 | | ``oid``, | ``text``, *``name``* | | | *``object_id``* | ``text``, | | | ``oid``, | *``identity``* | | | *``object_sub_id``* | ``text`` | | | ``integer``) | | | +----------------------+----------------------+----------------------+ | ``pg | *``type``* ``text``, | 得到一个数据库 | | _identify_object_as_ | *``name``* | 对象的地址的外部表示 | | address(catalog_id`` | ``text[]``, | | | ``oid``, | *``args``* | | | *``object_id``* | ``text[]`` | | | ``oid``, | | | | *``object_sub_id``* | | | | ``integer``) | | | +----------------------+----------------------+----------------------+ | ``pg_get_o | *``class_id``* | 从一个数据库对象的 | | bject_address(type`` | ``oid``, | 内部表示得到它的地址 | | ``text``, *``name``* | *``object_id``* | | | ``text[]``, | ``oid``, | | | *``args``* | *``object_sub_id``* | | | ``text[]``) | ``int32`` | | +----------------------+----------------------+----------------------+ ``pg_describe_object``\ 返回由目录OID、对象OID以及子对象ID（例如表中的一个列号，当子对象引用了一整个对象时其ID为零）指定的数据库对象的文本描述。这种描述是为 了人类可读的，并且可能是被翻译过的，具体取决于服务器配置。这有助于确定一 个存储在\ ``pg_depend``\ 目录中的对象的标识。 ``pg_identify_object``\ 返回一行，其中包含有足以唯一标识 由目录 OID、对象 OID 和一个（可能为零的）子对象 ID 指定的数据库对象的信息。 该信息是共机器读取的，并且不会被翻译。\ *``type``*\ 标识数据库对象 的类型；\ *``schema``*\ 是该对象所属的模式名，如果对象类型不属于 模式则为\ ``NULL``\ ；如果名称（加上方案名，如果相关）足以唯一标识对象，则\ *``name``*\ 就是对象的名称（必要时会被加上引号），否则为\ ``NULL``\ ；\ *``identity``*\ 是完整的对象标识， 它会表现为与对象类型相关的精确格式，并且如有必要，该格式中的每个部分都会 被模式限定。 ``pg_identify_object_as_address``\ 返回一行，其中包含有 足以唯一标识由目录 OID、对象 OID 和一个（可能为零的）子对象 ID 指定的数据 库对象的信息。返回的信息独立于当前服务器，也就是说，它可以被用来在另一个 服务器中标识一个具有相同命名的对象。\ *``type``*\ 标识数据库对象 的类型；\ *``object_names``*\ 和\ *``object_args``*\ 是文本数组，它们一起 构成了对对象的引用。这三个值可以被传递给 ``pg_get_object_address``\ 以获得该对象的内部地址。这个函数是 ``pg_get_object_address``\ 的逆函数。 ``pg_get_object_address``\ 返回一行，其中包含有足以唯一 标识由类型、对象名和参数数组指定的数据库对象的信息。返回值可以被用在诸如 ``pg_depend``\ 等系统目录中并且可以被传递给 ``pg_identify_object``\ 或\ ``pg_describe_object``\ 等其他 系统函数。\ *``class_id``*\ 是包含该对象的系统目录 OID； *``objid``*\ 是对象本身的 OID，而 *``objsubid``*\ 是子对象 ID，如果没有则为零。这个函数是 ``pg_identify_object_as_address``\ 的逆函数。 `表 9.73 `__\ 中展示的函数抽取注释，注释是由\ `COMMENT `__\ 命令在以前存储的。如果对指定参数找不到注释，则返回空值。 .. container:: table :name: FUNCTIONS-INFO-COMMENT-TABLE **表 9.73. 注释信息函数** .. container:: table-contents +----------------------------+----------+----------------------------+ | 名称 | 返回类型 | 描述 | +============================+==========+============================+ | ``co | ``text`` | 为一个表列获得注释 | | l_description(table_oid``, | | | | *``column_number``*) | | | +----------------------------+----------+----------------------------+ | ``obj | ``text`` | 为一个数据库对象获得注释 | | _description(object_oid``, | | | | *``catalog_name``*) | | | +----------------------------+----------+----------------------------+ | ``obj | ``text`` | 为一个数据库对象 | | _description(object_oid``) | | 获得注释（\ *已被废弃*\ ） | +----------------------------+----------+----------------------------+ | ``shobj | ``text`` | 为 | | _description(object_oid``, | | 一个共享数据库对象获得注释 | | *``catalog_name``*) | | | +----------------------------+----------+----------------------------+ ``col_description``\ 为一个表列返回注释，该表列由所在表的 OID 和它的列号指定（\ ``obj_description``\ 不能被用在表列，因为表列没有自己的 OID）。 ``obj_description``\ 的双参数形式返回一个由其 OID 和所在系统目录名称指定的数据库对象的注释。例如，\ ``obj_description(123456,'pg_class')``\ 将会检索出 OID 为123456的表的注释。\ ``obj_description``\ 的单参数形式只要求对象 OID。它已经被废弃，因为无法保证 OID 在不同系统目录之间是唯一的；这样可能会返回错误的注释。 ``shobj_description``\ 用起来就像\ ``obj_description``\ ，但是前者是用于检索共享对象上的注释。某些系统目录对于一个集簇中的所有数据库是全局的，并且其中的对象的描述也是全局存储的。 `表 9.74 `__\ 中展示的函数以一种可导出的形式提供了服务器事务信息。这些函数的主要用途是判断在两个快照之间哪些事务被提交。 .. container:: table :name: FUNCTIONS-TXID-SNAPSHOT **表 9.74. 事务 ID 和快照** .. container:: table-contents +-----------------------+-------------------+-----------------------+ | 名称 | 返回类型 | 描述 | +=======================+===================+=======================+ | ``txid_current()`` | ``bigint`` | 获得当前事务 | | | | ID，如果当前事务没有 | | | | ID 则分配一个新的 ID | +-----------------------+-------------------+-----------------------+ | ``txid_cu | ``bigint`` | 与\ ` | | rrent_if_assigned()`` | | `txid_current()``\ 相 | | | | 同，但是在事务没有分 | | | | 配ID时是返回空值而不 | | | | 是分配一个新的事务ID | +-----------------------+-------------------+-----------------------+ | ``txid | ``txid_snapshot`` | 获得当前快照 | | _current_snapshot()`` | | | +-----------------------+-------------------+-----------------------+ | ``txid_snapshot | ``setof bigint`` | 获得 | | _xip(txid_snapshot``) | | 快照中正在进行的事务 | | | | ID | +-----------------------+-------------------+-----------------------+ | ``txid_snapshot_ | ``bigint`` | 获得快照的\ ``xmax`` | | xmax(txid_snapshot``) | | | +-----------------------+-------------------+-----------------------+ | ``txid_snapshot_ | ``bigint`` | 获得快照的\ ``xmin`` | | xmin(txid_snapshot``) | | | +-----------------------+-------------------+-----------------------+ | ``txid_visible_ | ``boolean`` | 事务 ID | | in_snapshot(bigint``, | | 在快照中可见 | | *``txid_snapshot``*) | | 吗？（不能用于子事务 | | | | ID） | +-----------------------+-------------------+-----------------------+ | `` | ``text`` | 报告给定事务的状 | | txid_status(bigint``) | | 态：\ ``committed``\ | | | | 、\ ``aborted``\ 、\ | | | | ``in progress``\ ，如 | | | | 果事务ID太老则为空值 | +-----------------------+-------------------+-----------------------+ 内部事务 ID 类型（\ ``xid``\ ）是 32 位宽并且每 40 亿个事务就会回卷。但是，这些函数导出一种 64 位格式，它被使用一个“世代”计数器，这样在一个安装的生命期内不会回卷。这些函数使用的数据类型\ ``txid_snapshot``\ 存储了在一个特定时刻有关事务 ID 可见性的信息。它的成分在\ `表 9.75 `__\ 中描述。 .. container:: table :name: FUNCTIONS-TXID-SNAPSHOT-PARTS **表 9.75. 快照成分** .. container:: table-contents +--------------+------------------------------------------------------+ | 名称 | 描述 | +==============+======================================================+ | ``xmin`` | 仍然活动的最早的事务 ID | | | （txid）。所有更早的 | | | 事务要么已经被提交并且可见，要么已经被回滚并且死亡。 | +--------------+------------------------------------------------------+ | ``xmax`` | 第一个还未分配的 txid。所有大于等于它的 txid | | | 在快照的时刻还没有开始，并且因此是不可见的。 | +--------------+------------------------------------------------------+ | ``xip_list`` | 在快照时刻活动的 | | | txid。这个列 | | | 表只包括那些位于\ ``xmin``\ 和\ ``xmax``\ 之间的活动 | | | txid；可能有活动的超过\ ``xmax``\ 的 | | | txid。一个 | | | 满足\ ``xmin <= txid < xmax``\ 并且不在这个列表中的 | | | txid | | | 在快照时刻已经结束，并且因此 | | | 根据其提交状态要么可见要么死亡。该列表不包括子事务的 | | | txid。 | +--------------+------------------------------------------------------+ ``txid_snapshot``\ 的文本表示是\ ``xmin``:*``xmax``*:*``xip_list``*\ 。例如\ ``10:20:10,14,15``\ 表示\ ``xmin=10, xmax=20, xip_list=10, 14, 15``\ 。 ``txid_status(bigint)``\ 报告一个近期事务的提交状态。当一个应用和数据库服务器的连接在\ ``COMMIT``\ 正在进行时断开，应用可以用它来判断事务是提交了还是中止了。一个事务的状态将被报告为\ ``in progress``\ 、\ ``committed``\ 或者\ ``aborted``\ ，前提是该事务的发生时间足够近，这样系统才会保留它的提交状态。如果事务太老，则系统中不会留下对该事务的引用并且提交状态信息也已经被抛弃，那么这个函数将会返回NULL。注意，预备事务会被报告为\ ``in progress``\ ，如果应用需要判断该txid是否是一个预备事务，应用必须检查\ ```pg_prepared_xacts`` `__\ 。 `表 9.76 `__\ 中展示的函数提供了有关于 已经提交事务的信息。这些函数主要提供有关事务何时被提交的信息。只有当 `track_commit_timestamp `__\ 配置选项被启用时它们才能 提供有用的数据，并且只对已提交事务提供数据。 .. container:: table :name: FUNCTIONS-COMMIT-TIMESTAMP **表 9.76. 已提交事务信息** .. container:: table-contents +----------------------+----------------------+----------------------+ | 名称 | 返回类型 | 描述 | +======================+======================+======================+ | | ``timest | 得到 | | ``pg_xact_com | amp with time zone`` | 一个事务的提交时间戳 | | mit_timestamp(xid``) | | | +----------------------+----------------------+----------------------+ | | *``xid``* ``xid``, | 得到最后 | | ``pg_las | *``timestamp``* | 一个已提交事务的事务 | | t_committed_xact()`` | ``timest | ID 和提交时间戳 | | | amp with time zone`` | | +----------------------+----------------------+----------------------+ `表 9.77 `__\ 中所展示的函数能打印\ ``initdb``\ 期间初始化的信息，例如系统目录版本。它们也能显示有关预写式日志和检查点处理的信息。这些信息是集簇范围内的，不与任何特定的一个数据库相关。对于同一种来源，它们返回和\ `pg_controldata `__\ 大致相同的信息，不过其形式更适合于SQL函数。 .. container:: table :name: FUNCTIONS-CONTROLDATA **表 9.77. 控制数据函数** .. container:: table-contents =========================== ========== ================================ 名称 返回类型 描述 =========================== ========== ================================ ``record`` 返回有关当前检查点状态的信息。 ``pg_control_checkpoint()`` ``pg_control_system()`` ``record`` 返回有关当前控制文件状态的信息。 ``pg_control_init()`` ``record`` 返回有关集簇初始化状态的信息。 ``pg_control_recovery()`` ``record`` 返回有关恢复状态的信息。 =========================== ========== ================================ ``pg_control_checkpoint``\ 返回一个\ `表 9.78 `__\ 中所示的记录 .. container:: table :name: FUNCTIONS-PG-CONTROL-CHECKPOINT **表 9.78. ``pg_control_checkpoint``\ 列** .. container:: table-contents ======================== ============================ 列名 数据类型 ======================== ============================ ``checkpoint_location`` ``pg_lsn`` ``redo_lsn`` ``pg_lsn`` ``redo_wal_file`` ``text`` ``timeline_id`` ``integer`` ``prev_timeline_id`` ``integer`` ``full_page_writes`` ``boolean`` ``next_xid`` ``text`` ``next_oid`` ``oid`` ``next_multixact_id`` ``xid`` ``next_multi_offset`` ``xid`` ``oldest_xid`` ``xid`` ``oldest_xid_dbid`` ``oid`` ``oldest_active_xid`` ``xid`` ``oldest_multi_xid`` ``xid`` ``oldest_multi_dbid`` ``oid`` ``oldest_commit_ts_xid`` ``xid`` ``newest_commit_ts_xid`` ``xid`` ``checkpoint_time`` ``timestamp with time zone`` ======================== ============================ ``pg_control_system``\ 返回一个\ `表 9.79 `__\ 中所示的记录 .. container:: table :name: FUNCTIONS-PG-CONTROL-SYSTEM **表 9.79. ``pg_control_system``\ 列** .. container:: table-contents ============================ ============================ 列名 数据类型 ============================ ============================ ``pg_control_version`` ``integer`` ``catalog_version_no`` ``integer`` ``system_identifier`` ``bigint`` ``pg_control_last_modified`` ``timestamp with time zone`` ============================ ============================ ``pg_control_init``\ 返回一个\ `表 9.80 `__\ 中所示的记录 .. container:: table :name: FUNCTIONS-PG-CONTROL-INIT **表 9.80. ``pg_control_init``\ 列** .. container:: table-contents ============================== =========== 列名 数据类型 ============================== =========== ``max_data_alignment`` ``integer`` ``database_block_size`` ``integer`` ``blocks_per_segment`` ``integer`` ``wal_block_size`` ``integer`` ``bytes_per_wal_segment`` ``integer`` ``max_identifier_length`` ``integer`` ``max_index_columns`` ``integer`` ``max_toast_chunk_size`` ``integer`` ``large_object_chunk_size`` ``integer`` ``float4_pass_by_value`` ``boolean`` ``float8_pass_by_value`` ``boolean`` ``data_page_checksum_version`` ``integer`` ============================== =========== ``pg_control_recovery``\ 返回一个\ `表 9.81 `__\ 中所示的记录 .. container:: table :name: FUNCTIONS-PG-CONTROL-RECOVERY **表 9.81. ``pg_control_recovery``\ 列** .. container:: table-contents ================================= =========== 列名 数据类型 ================================= =========== ``min_recovery_end_lsn`` ``pg_lsn`` ``min_recovery_end_timeline`` ``integer`` ``backup_start_lsn`` ``pg_lsn`` ``backup_end_lsn`` ``pg_lsn`` ``end_of_backup_record_required`` ``boolean`` ================================= ===========