从补丁 198 开始，Amazon Redshift 将不再支持创建新的 Python UDF。现有的 Python UDF 将继续正常运行至 2026 年 6 月 30 日。有关更多信息，请参阅[博客文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
# 系统表和视图参考
Amazon Redshift 有许多包含系统运行方式相关信息的系统表和视图。您可以像查询任何其他数据库表那样查询这些系统表和视图。本部分提供一些系统表查询示例并予以讲解：
+ 生成的系统表和视图的类型有何不同
+ 您可以从这些表中获得哪些类型的信息
+ 如何将 Amazon Redshift 系统表联接到目录表
+ 如何管理系统表日志文件的增长
某些系统表只能由 AWS 人员用于诊断目的。以下部分讨论可供系统管理员或其他数据库用户查询有用信息的系统表。
**注意**
自动或手动集群备份（快照）中不包含系统表。STL 系统视图保留七天的日志历史记录。保留日志不要求客户执行任何操作，但如果需要将日志数据存储超过 7 天，则必须定期将日志数据复制到其他表，或将日志数据卸载到 Amazon S3。
**Topics**
+ [系统表和视图类型](#c_types-of-system-tables-and-views)
+ [系统表和视图中的数据可见性](#c_visibility-of-data)
+ [将仅预调配的查询迁移到 SYS 监控视图查询](#sys_view_migration-use_cases)
+ [使用 SYS 监控视图改进查询标识符跟踪](#sys_view_migration-query-id)
+ [系统表查询、进程和会话 ID](#system-table-query-process-session-ids)
+ [SVV 元数据视图](svv_views.md)
+ [SYS 监控视图](serverless_views-monitoring.md)
+ [用于迁移到 SYS 监控视图的系统视图映射](sys_view_migration.md)
+ [系统监控（仅已预置）](c_intro_system_views.md)
+ [系统目录表](c_intro_catalog_views.md)
## 系统表和视图类型
系统表和视图分为几种类型：
+ SVV 视图包含有关数据库对象的信息，并引用了临时 STV 表。
+ SYS 视图用于监控预置集群和无服务器工作组的查询和工作负载使用情况。
+ STL 视图从长久保存到磁盘的用于提供系统历史记录的日志生成。
+ STV 表是虚拟系统表，包含当前系统数据的快照。它们基于临时的内存数据，不会长久保存到基于磁盘的日志或常规表中。
+ SVCS 视图提供了有关主集群和并发扩展集群上的查询的详细信息。
+ SVL 视图提供有关主集群查询的详细信息。
系统表及视图不使用与常规表相同的一致性模型。在查询它们时，特别是查询 STV 表和 SVV 视图时，一定要注意这个问题。例如，对于包含列 c1 的常规表 t1，下面的查询不会返回任何行：
```
select * from t1
where c1 > (select max(c1) from t1)
```
但是，下面针对系统表的查询可能返回行：
```
select * from stv_exec_state
where currenttime > (select max(currenttime) from stv_exec_state)
```
该查询可能返回行的原因在于：currenttime 是临时的，查询中的两个引用在求值时可能返回不同的值。
另一方面，下面的查询也可能不返回行：
```
select * from stv_exec_state
where currenttime = (select max(currenttime) from stv_exec_state)
```
## 系统表和视图中的数据可见性
**注意**
在记录有关对 Data Catalog 视图执行的查询的信息时，Amazon Redshift 会自动屏蔽某些系统表列，以防止泄露敏感元数据。有关更多信息，请参阅《Amazon Redshift Management Guide》**中的 [Secure logging](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing-secure-logging.html)。
系统表及视图中的数据有两类可见性：对用户可见和对超级用户可见。
只有具有超级用户权限的用户才能看到属于超级用户可见类别的表中的数据。普通用户可以查看对用户可见的表中的数据。要使普通用户能够访问对超级用户可见的表，请向普通用户授予对该表的 SELECT 权限。有关更多信息，请参阅 [GRANT](r_GRANT.md)。
默认情况下，在大多数对用户可见的表中，普通用户看不到其他用户生成的行。如果向普通用户授予 [SYSLOG ACCESS UNRESTRICTED](r_ALTER_USER.md#alter-user-syslog-access)，则该用户可以查看用户可见表中的所有行，包括由其他用户生成的行。有关更多信息，请参阅 [ALTER USER](r_ALTER_USER.md) 或 [CREATE USER](r_CREATE_USER.md)。SVV\$1TRANSACTIONS 中的所有行都对所有用户可见。有关数据可见性的更多信息，请参阅 AWS re:Post 知识库文章[如何允许 Amazon Redshift 数据库普通用户查看我的集群中其他用户系统表中的数据？](https://repost.aws/knowledge-center/amazon-redshift-system-tables)。
对于元数据视图，Amazon Redshift 不允许具有 SYSLOG ACCESS UNRESTRICTED 权限的用户查看。
**注意**
如果向用户授予对系统表的无限制访问权限，用户便可以看到由其他用户生成的数据。例如，STL\$1QUERY 和 STL\$1QUERY\$1TEXT 包含 INSERT、UPDATE 和 DELETE 语句的完整文本 (其中可能包含敏感的用户生成数据)。
超级用户可以查看所有表中的所有行。要使普通用户能够访问对超级客户可见的表，[GRANT](r_GRANT.md)请向普通用户授予对该表的 SELECT 权限。
### 筛选系统生成的查询
与查询有关的系统表和视图（如 SVL\$1QUERY\$1SUMMARY、SVL\$1QLOG 等）通常包含大量自动生成的语句，Amazon Redshift 使用这些语句监控数据库的状态。这些系统生成的查询对超级用户可见，但用处不大。从使用 `userid` 列的系统表或视图中进行选择时，如果要过滤掉它们，则可在 WHERE 子句中添加条件 `userid > 1`。例如：
```
select * from svl_query_summary where userid > 1
```
## 将仅预调配的查询迁移到 SYS 监控视图查询
### 从预调配集群迁移到 Amazon Redshift Serverless
如果您要将预调配集群迁移到 Amazon Redshift Serverless，则您可能具有使用以下系统视图的查询，而这些视图仅存储预调配集群中的数据。
+ 所有 STL 视图
+ 所有 STV 视图
+ 所有 SVCS 视图
+ 所有 SVL 视图
+ 部分 SVV 视图
+ 有关 Amazon Redshift Serverless 中不支持的 SVV 视图的完整列表，请参阅《Amazon Redshift 管理指南》**中的[使用 Amazon Redshift Serverless 监控查询和工作负载](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-monitoring.html)底部的列表。
要继续使用查询，请将它们重新调整为使用在 SYS 监控视图中定义的列，这些列与仅预调配视图中的列相对应。要查看仅预调配视图和 SYS 监控视图之间的映射关系，请转至[用于迁移到 SYS 监控视图的系统视图映射](sys_view_migration.md)
### 停留在预调配集群上时更新查询
如果您不迁移到 Amazon Redshift Serverless，则可能仍需要更新现有查询。SYS 监控视图专为易于使用和降低复杂性而设计，并提供了一系列完整的指标来进行有效的监控和故障排除。使用 SYS 视图（如 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 和 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)），其中整合了多个仅预调配视图的信息，可以简化查询。
## 使用 SYS 监控视图改进查询标识符跟踪
诸如 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 和 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 之类的 SYS 监控视图包含 query\$1id 列，该列包含用户的查询标识符。同样，诸如 [STL\$1QUERY](r_STL_QUERY.md) 和 [SVL\$1QLOG](r_SVL_QLOG.md) 之类的仅预置视图包含查询列，该列还包含查询标识符。但是，SYS 系统视图中记录的查询标识符与仅预置视图中记录的查询标识符不同。
SYS 视图的 query\$1id 列值与仅预置视图的查询列值之间的区别如下：
+ 在 SYS 视图中，query\$1id 列以原始形式记录用户提交的查询。为了提高性能，Amazon Redshift 优化器可能会将它们分解为子查询，但您运行的单个查询在 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中仍然只有一行。如果您想查看各个子查询，可以在 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到它们。
+ 在仅预置视图中，查询列记录子查询级别的查询。如果 Amazon Redshift 优化器将您的原始查询重写为多个子查询，则对于您运行的单个查询，[STL\$1QUERY](r_STL_QUERY.md) 中将有多行具有不同的查询标识符值。
将监控和诊断查询从仅预置视图迁移到 SYS 视图时，请考虑这种差异并相应地编辑查询。有关 Amazon Redshift 如何处理查询的更多信息，请参阅[查询计划和执行工作流程](c-query-planning.md)。
### 示例
有关 Amazon Redshift 在仅预调配视图和 SYS 监控视图中如何以不同的方式记录查询的示例，请参阅以下示例查询。这是按照在 Amazon Redshift 中运行的方式编写的查询。
```
SELECT
s_name
, COUNT(*) AS numwait
FROM
supplier,
lineitem l1,
orders,
nation
WHERE s_suppkey = l1.l_suppkey
AND o_orderkey = l1.l_orderkey
AND o_orderstatus = 'F'
AND l1.l_receiptdate > l1.l_commitdate
AND EXISTS (SELECT
*
FROM
lineitem l2
WHERE l2.l_orderkey = l1.l_orderkey
AND l2.l_suppkey <> l1.l_suppkey )
AND NOT EXISTS (SELECT
*
FROM
lineitem l3
WHERE l3.l_orderkey = l1.l_orderkey
AND l3.l_suppkey <> l1.l_suppkey
AND l3.l_receiptdate > l3.l_commitdate )
AND s_nationkey = n_nationkey
AND n_name = 'UNITED STATES'
GROUP BY
s_name
ORDER BY
numwait DESC
, s_name LIMIT 100;
```
在后台，Amazon Redshift 查询优化器将上述用户提交的查询重写为 5 个子查询。
第一个子查询创建一个临时表来实现一个子查询。
```
CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey
, l_suppkey
, s_name ) AS SELECT
l1.l_orderkey
, l1.l_suppkey
, public.supplier.s_name
FROM
public.lineitem AS l1,
public.nation,
public.orders,
public.supplier
WHERE l1.l_commitdate < l1.l_receiptdate
AND l1.l_orderkey = public.orders.o_orderkey
AND l1.l_suppkey = public.supplier.s_suppkey
AND public.nation.n_name = 'UNITED STATES'::CHAR(8)
AND public.nation.n_nationkey = public.supplier.s_nationkey
AND public.orders.o_orderstatus = 'F'::CHAR(1);
```
第二个子查询从临时表中收集统计数据。
```
padb_fetch_sample: select count(*) from volt_tt_606590308b512;
```
第三个子查询创建另一个临时表来实现另一个子查询，引用上面创建的临时表。
```
CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey
, l_suppkey) AS (SELECT
volt_tt_606590308b512.l_orderkey
, volt_tt_606590308b512.l_suppkey
FROM
public.lineitem AS l2,
volt_tt_606590308b512
WHERE l2.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l2.l_orderkey = volt_tt_606590308b512.l_orderkey)
EXCEPT distinct (SELECT volt_tt_606590308b512.l_orderkey, volt_tt_606590308b512.l_suppkey
FROM public.lineitem AS l3, volt_tt_606590308b512
WHERE l3.l_commitdate < l3.l_receiptdate
AND l3.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l3.l_orderkey = volt_tt_606590308b512.l_orderkey);
```
第四个子查询再次收集临时表的统计数据。
```
padb_fetch_sample: select count(*) from volt_tt_606590308c2ef
```
最后一个子查询使用上面创建的临时表生成输出。
```
SELECT
volt_tt_606590308b512.s_name AS s_name
, COUNT(*) AS numwait
FROM
volt_tt_606590308b512,
volt_tt_606590308c2ef
WHERE volt_tt_606590308b512.l_orderkey = volt_tt_606590308c2ef.l_orderkey
AND volt_tt_606590308b512.l_suppkey = volt_tt_606590308c2ef.l_suppkey
GROUP BY
1
ORDER BY
2 DESC
, 1 ASC LIMIT 100;
```
在仅预置系统视图 STL\$1QUERY 中，Amazon Redshift 在子查询级别记录了五行，如下所示：
```
SELECT userid, xid, pid, query, querytxt::varchar(100);
FROM stl_query
WHERE xid = 48237350
ORDER BY xid, starttime;
userid | xid | pid | query | querytxt
--------+----------+------------+----------+------------------------------------------------------------------------------------------------------
101 | 48237350 | 1073840810 | 12058151 | CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey, l_suppkey, s_name) AS SELECT l1.l_orderkey, l1.l
101 | 48237350 | 1073840810 | 12058152 | padb_fetch_sample: select count(*) from volt_tt_606590308b512
101 | 48237350 | 1073840810 | 12058156 | CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey, l_suppkey) AS (SELECT volt_tt_606590308b512.l_or
101 | 48237350 | 1073840810 | 12058168 | padb_fetch_sample: select count(*) from volt_tt_606590308c2ef
101 | 48237350 | 1073840810 | 12058170 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.
(5 rows)
```
在 SYS 监控视图 SYS\$1QUERY\$1HISTORY 中，Amazon Redshift 按如下方式记录查询：
```
SELECT user_id, transaction_id, session_id, query_id, query_text::varchar(100)
FROM sys_query_history
WHERE transaction_id = 48237350
ORDER BY start_time;
user_id | transaction_id | session_id | query_id | query_text
---------+----------------+------------+----------+------------------------------------------------------------------------------------------------------
101 | 48237350 | 1073840810 | 12058149 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.
```
在 SYS\$1QUERY\$1DETAIL 中，可以使用来自 SYS\$1QUERY\$1HISTORY 的 query\$1id 值查找子查询级详细信息。child\$1query\$1sequence 列显示子查询的执行顺序。有关 SYS\$1QUERY\$1DETAIL 中各列的更多信息，请参阅 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。
```
select user_id,
query_id,
child_query_sequence,
stream_id,
segment_id,
step_id,
start_time,
end_time,
duration,
blocks_read,
blocks_write,
local_read_io,
remote_read_io,
data_skewness,
time_skewness,
is_active,
spilled_block_local_disk,
spilled_block_remote_disk
from sys_query_detail
where query_id = 12058149
and step_id = -1
order by query_id,
child_query_sequence,
stream_id,
segment_id,
step_id;
user_id | query_id | child_query_sequence | stream_id | segment_id | step_id | start_time | end_time | duration | blocks_read | blocks_write | local_read_io | remote_read_io | data_skewness | time_skewness | is_active | spilled_block_local_disk | spilled_block_remote_disk
---------+----------+----------------------+-----------+------------+---------+----------------------------+----------------------------+----------+-------------+--------------+---------------+----------------+---------------+---------------+-----------+--------------------------+---------------------------
101 | 12058149 | 1 | 0 | 0 | -1 | 2023-09-27 15:40:38.512415 | 2023-09-27 15:40:38.533333 | 20918 | 0 | 0 | 0 | 0 | 0 | 44 | f | 0 | 0
101 | 12058149 | 1 | 1 | 1 | -1 | 2023-09-27 15:40:39.931437 | 2023-09-27 15:40:39.972826 | 41389 | 12 | 0 | 12 | 0 | 0 | 77 | f | 0 | 0
101 | 12058149 | 1 | 2 | 2 | -1 | 2023-09-27 15:40:40.584412 | 2023-09-27 15:40:40.613982 | 29570 | 32 | 0 | 32 | 0 | 0 | 25 | f | 0 | 0
101 | 12058149 | 1 | 2 | 3 | -1 | 2023-09-27 15:40:40.582038 | 2023-09-27 15:40:40.615758 | 33720 | 0 | 0 | 0 | 0 | 0 | 1 | f | 0 | 0
101 | 12058149 | 1 | 3 | 4 | -1 | 2023-09-27 15:40:46.668766 | 2023-09-27 15:40:46.705456 | 36690 | 24 | 0 | 15 | 0 | 0 | 17 | f | 0 | 0
101 | 12058149 | 1 | 4 | 5 | -1 | 2023-09-27 15:40:46.707209 | 2023-09-27 15:40:46.709176 | 1967 | 0 | 0 | 0 | 0 | 0 | 18 | f | 0 | 0
101 | 12058149 | 1 | 4 | 6 | -1 | 2023-09-27 15:40:46.70656 | 2023-09-27 15:40:46.71289 | 6330 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 1 | 5 | 7 | -1 | 2023-09-27 15:40:46.71405 | 2023-09-27 15:40:46.714343 | 293 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 2 | 0 | 0 | -1 | 2023-09-27 15:40:52.083907 | 2023-09-27 15:40:52.087854 | 3947 | 0 | 0 | 0 | 0 | 0 | 35 | f | 0 | 0
101 | 12058149 | 2 | 1 | 1 | -1 | 2023-09-27 15:40:52.089632 | 2023-09-27 15:40:52.091129 | 1497 | 0 | 0 | 0 | 0 | 0 | 11 | f | 0 | 0
101 | 12058149 | 2 | 1 | 2 | -1 | 2023-09-27 15:40:52.089008 | 2023-09-27 15:40:52.091306 | 2298 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 3 | 0 | 0 | -1 | 2023-09-27 15:40:56.882013 | 2023-09-27 15:40:56.897282 | 15269 | 0 | 0 | 0 | 0 | 0 | 29 | f | 0 | 0
101 | 12058149 | 3 | 1 | 1 | -1 | 2023-09-27 15:40:59.718554 | 2023-09-27 15:40:59.722789 | 4235 | 0 | 0 | 0 | 0 | 0 | 13 | f | 0 | 0
101 | 12058149 | 3 | 2 | 2 | -1 | 2023-09-27 15:40:59.800382 | 2023-09-27 15:40:59.807388 | 7006 | 0 | 0 | 0 | 0 | 0 | 58 | f | 0 | 0
101 | 12058149 | 3 | 3 | 3 | -1 | 2023-09-27 15:41:06.488685 | 2023-09-27 15:41:06.493825 | 5140 | 0 | 0 | 0 | 0 | 0 | 56 | f | 0 | 0
101 | 12058149 | 3 | 3 | 4 | -1 | 2023-09-27 15:41:06.486206 | 2023-09-27 15:41:06.497756 | 11550 | 0 | 0 | 0 | 0 | 0 | 2 | f | 0 | 0
101 | 12058149 | 3 | 4 | 5 | -1 | 2023-09-27 15:41:06.499201 | 2023-09-27 15:41:06.500851 | 1650 | 0 | 0 | 0 | 0 | 0 | 15 | f | 0 | 0
101 | 12058149 | 3 | 4 | 6 | -1 | 2023-09-27 15:41:06.498609 | 2023-09-27 15:41:06.500949 | 2340 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 3 | 5 | 7 | -1 | 2023-09-27 15:41:06.502945 | 2023-09-27 15:41:06.503282 | 337 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 4 | 0 | 0 | -1 | 2023-09-27 15:41:06.62899 | 2023-09-27 15:41:06.631452 | 2462 | 0 | 0 | 0 | 0 | 0 | 22 | f | 0 | 0
101 | 12058149 | 4 | 1 | 1 | -1 | 2023-09-27 15:41:06.632313 | 2023-09-27 15:41:06.63391 | 1597 | 0 | 0 | 0 | 0 | 0 | 20 | f | 0 | 0
101 | 12058149 | 4 | 1 | 2 | -1 | 2023-09-27 15:41:06.631726 | 2023-09-27 15:41:06.633813 | 2087 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 5 | 0 | 0 | -1 | 2023-09-27 15:41:12.571974 | 2023-09-27 15:41:12.584234 | 12260 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0
101 | 12058149 | 5 | 0 | 1 | -1 | 2023-09-27 15:41:12.569815 | 2023-09-27 15:41:12.585391 | 15576 | 0 | 0 | 0 | 0 | 0 | 4 | f | 0 | 0
101 | 12058149 | 5 | 1 | 2 | -1 | 2023-09-27 15:41:13.758513 | 2023-09-27 15:41:13.76401 | 5497 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0
101 | 12058149 | 5 | 1 | 3 | -1 | 2023-09-27 15:41:13.749 | 2023-09-27 15:41:13.772987 | 23987 | 0 | 0 | 0 | 0 | 0 | 32 | f | 0 | 0
101 | 12058149 | 5 | 2 | 4 | -1 | 2023-09-27 15:41:13.799526 | 2023-09-27 15:41:13.813506 | 13980 | 0 | 0 | 0 | 0 | 0 | 62 | f | 0 | 0
101 | 12058149 | 5 | 2 | 5 | -1 | 2023-09-27 15:41:13.798823 | 2023-09-27 15:41:13.813651 | 14828 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
(28 rows)
```
## 系统表查询、进程和会话 ID
在对系统表中显示的查询、进程和会话 ID 进行分析时，请注意以下几点：
+ 查询 ID 值（在 `query_id` 和 `query` 等列中）可在以后重复使用。
+ 进程 ID 值或会话 ID 值（在 `process_id`、`pid` 和 `session_id` 等列中）可在以后重复使用。
+ 事务 ID 值（在 `transaction_id` 和 `xid` 等列中）是唯一的。
# SVV 元数据视图
SVV 视图是 Amazon Redshift 中的系统视图，其中包含有关数据库对象的信息。请注意，尽管它们存储诸如用户权限或表名称之类的信息，但它们并不适用于联接用户创建的关系。
**注意**
如果数据库响应因任何原因失败，Amazon Redshift 会报告 WARNING 而不是 ERROR。当您在数据共享中查询对象时，Amazon Redshift 不会发送 ERROR 消息。
**Topics**
+ [SVV\$1ACTIVE\$1CURSORS](r_SVV_ACTIVE_CURSORS.md)
+ [SVV\$1ALL\$1COLUMNS](r_SVV_ALL_COLUMNS.md)
+ [SVV\$1ALL\$1SCHEMAS](r_SVV_ALL_SCHEMAS.md)
+ [SVV\$1ALL\$1TABLES](r_SVV_ALL_TABLES.md)
+ [SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)
+ [SVV\$1ATTACHED\$1MASKING\$1POLICY](r_SVV_ATTACHED_MASKING_POLICY.md)
+ [SVV\$1COLUMNS](r_SVV_COLUMNS.md)
+ [SVV\$1COLUMN\$1PRIVILEGES](r_SVV_COLUMN_PRIVILEGES.md)
+ [SVV\$1COPY\$1JOB\$1INTEGRATIONS](SVV_COPY_JOB_INTEGRATIONS.md)
+ [SVV\$1DATABASE\$1PRIVILEGES](r_SVV_DATABASE_PRIVILEGES.md)
+ [SVV\$1DATASHARE\$1PRIVILEGES](r_SVV_DATASHARE_PRIVILEGES.md)
+ [SVV\$1DATASHARES](r_SVV_DATASHARES.md)
+ [SVV\$1DATASHARE\$1CONSUMERS](r_SVV_DATASHARE_CONSUMERS.md)
+ [SVV\$1DATASHARE\$1OBJECTS](r_SVV_DATASHARE_OBJECTS.md)
+ [SVV\$1DEFAULT\$1PRIVILEGES](r_SVV_DEFAULT_PRIVILEGES.md)
+ [SVV\$1DISKUSAGE](r_SVV_DISKUSAGE.md)
+ [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md)
+ [SVV\$1EXTERNAL\$1DATABASES](r_SVV_EXTERNAL_DATABASES.md)
+ [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md)
+ [SVV\$1EXTERNAL\$1SCHEMAS](r_SVV_EXTERNAL_SCHEMAS.md)
+ [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md)
+ [SVV\$1FUNCTION\$1PRIVILEGES](r_SVV_FUNCTION_PRIVILEGES.md)
+ [SVV\$1GEOGRAPHY\$1COLUMNS](r_SVV_GEOGRAPHY_COLUMNS.md)
+ [SVV\$1GEOMETRY\$1COLUMNS](r_SVV_GEOMETRY_COLUMNS.md)
+ [SVV\$1IAM\$1PRIVILEGES](r_SVV_IAM_PRIVILEGES.md)
+ [SVV\$1IDENTITY\$1PROVIDERS](r_SVV_IDENTITY_PROVIDERS.md)
+ [SVV\$1INTEGRATION](r_SVV_INTEGRATION.md)
+ [SVV\$1INTEGRATION\$1TABLE\$1MAPPING](r_SVV_INTEGRATION_TABLE_MAPPING.md)
+ [SVV\$1INTEGRATION\$1TABLE\$1STATE](r_SVV_INTEGRATION_TABLE_STATE.md)
+ [SVV\$1INTERLEAVED\$1COLUMNS](r_SVV_INTERLEAVED_COLUMNS.md)
+ [SVV\$1LANGUAGE\$1PRIVILEGES](r_SVV_LANUGAGE_PRIVILEGES.md)
+ [SVV\$1MASKING\$1POLICY](r_SVV_MASKING_POLICY.md)
+ [SVV\$1ML\$1MODEL\$1INFO](r_SVV_ML_MODEL_INFO.md)
+ [SVV\$1ML\$1MODEL\$1PRIVILEGES](r_SVV_ML_MODEL_PRIVILEGES.md)
+ [SVV\$1MV\$1DEPENDENCY](r_SVV_MV_DEPENDENCY.md)
+ [SVV\$1MV\$1INFO](r_SVV_MV_INFO.md)
+ [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)
+ [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md)
+ [SVV\$1REDSHIFT\$1COLUMNS](r_SVV_REDSHIFT_COLUMNS.md)
+ [SVV\$1REDSHIFT\$1DATABASES](r_SVV_REDSHIFT_DATABASES.md)
+ [SVV\$1REDSHIFT\$1FUNCTIONS](r_SVV_REDSHIFT_FUNCTIONS.md)
+ [SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA](r_SVV_REDSHIFT_SCHEMA_QUOTA.md)
+ [SVV\$1REDSHIFT\$1SCHEMAS](r_SVV_REDSHIFT_SCHEMAS.md)
+ [SVV\$1REDSHIFT\$1TABLES](r_SVV_REDSHIFT_TABLES.md)
+ [SVV\$1RELATION\$1PRIVILEGES](r_SVV_RELATION_PRIVILEGES.md)
+ [SVV\$1RLS\$1APPLIED\$1POLICY](r_SVV_RLS_APPLIED_POLICY.md)
+ [SVV\$1RLS\$1ATTACHED\$1POLICY](r_SVV_RLS_ATTACHED_POLICY.md)
+ [SVV\$1RLS\$1POLICY](r_SVV_RLS_POLICY.md)
+ [SVV\$1RLS\$1RELATION](r_SVV_RLS_RELATION.md)
+ [SVV\$1ROLE\$1GRANTS](r_SVV_ROLE_GRANTS.md)
+ [SVV\$1ROLES](r_SVV_ROLES.md)
+ [SVV\$1SCHEMA\$1PRIVILEGES](r_SVV_SCHEMA_PRIVILEGES.md)
+ [SVV\$1SCHEMA\$1QUOTA\$1STATE](r_SVV_SCHEMA_QUOTA_STATE.md)
+ [SVV\$1SYSTEM\$1PRIVILEGES](r_SVV_SYSTEM_PRIVILEGES.md)
+ [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)
+ [SVV\$1TABLES](r_SVV_TABLES.md)
+ [SVV\$1TRANSACTIONS](r_SVV_TRANSACTIONS.md)
+ [SVV\$1USER\$1GRANTS](r_SVV_USER_GRANTS.md)
+ [SVV\$1USER\$1INFO](r_SVV_USER_INFO.md)
+ [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md)
+ [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md)
# SVV\$1ACTIVE\$1CURSORS
SVV\$1ACTIVE\$1CURSORS 显示当前打开的游标的详细信息。有关更多信息，请参阅 [DECLARE](declare.md)。
SVV\$1ACTIVE\$1CURSORS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。用户只能查看自己打开的光标。超级用户可以查看所有光标。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ACTIVE_CURSORS.html)
# SVV\$1ALL\$1COLUMNS
使用 SVV\$1ALL\$1COLUMNS 可以查看来自 Amazon Redshift 表的列的联合，如 SVV\$1REDSHIFT\$1COLUMNS 中所示，以及所有外部表中所有外部列的合并列表。有关 Amazon Redshift 列的信息，请参阅[SVV\$1REDSHIFT\$1COLUMNS](r_SVV_REDSHIFT_COLUMNS.md)。
SVV\$1ALL\$1COLUMNS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ALL_COLUMNS.html)
## 示例查询
下面的示例返回 SVV\$1ALL\$1COLUMNS 的输出。
```
SELECT *
FROM svv_all_columns
WHERE database_name = 'tickit_db'
AND TABLE_NAME = 'tickit_sales_redshift'
ORDER BY COLUMN_NAME,
SCHEMA_NAME
LIMIT 5;
database_name | schema_name | table_name | column_name | ordinal_position | column_default | is_nullable | data_type | character_maximum_length | numeric_precision | numeric_scale | remarks
--------------+-------------+-----------------------+-------------+------------------+----------------+-------------+-----------+--------------------------+-------------------+---------------+---------
tickit_db | public | tickit_sales_redshift | buyerid | 4 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | commission | 9 | | YES | numeric | | 8 | 2 |
tickit_db | public | tickit_sales_redshift | dateid | 7 | | NO | smallint | | 16 | 0 |
tickit_db | public | tickit_sales_redshift | eventid | 5 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | listid | 2 | | NO | integer | | 32 | 0 |
```
# SVV\$1ALL\$1SCHEMAS
使用 SVV\$1ALL\$1SCHEMAS 可以查看 Amazon Redshift schema 的联合，如 SVV\$1REDSHIFT\$1SCHEMAS 所示，以及所有数据库中所有外部 schema 的综合列表。有关 Amazon Redshift schema 的更多信息，请参阅[SVV\$1REDSHIFT\$1SCHEMAS](r_SVV_REDSHIFT_SCHEMAS.md)。
SVV\$1ALL\$1SCHEMAS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ALL_SCHEMAS.html)
## 示例查询
下面的示例返回 SVV\$1ALL\$1SCHEMAS 的输出。
```
SELECT *
FROM svv_all_schemas
WHERE database_name = 'tickit_db'
ORDER BY database_name,
SCHEMA_NAME;
database_name | schema_name | schema_owner | schema_type | schema_acl | source_database | schema_option
---------------+--------------------+--------------+-------------+------------+-----------------+---------------
tickit_db | public | 1 | shared | | |
```
# SVV\$1ALL\$1TABLES
使用 SVV\$1ALL\$1TABLES 可以查看 Amazon Redshift 表的联合，如 SVV\$1REDSHIFT\$1TABLES 中所示，以及所有外部 schema 中所有外部表的综合列表。有关 Amazon Redshift 表的信息，请参阅[SVV\$1REDSHIFT\$1TABLES](r_SVV_REDSHIFT_TABLES.md)。
SVV\$1ALL\$1TABLES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ALL_TABLES.html)
## 示例查询
以下示例返回 SVV\$1ALL\$1TABLES 的输出。
```
SELECT *
FROM svv_all_tables
WHERE database_name = 'tickit_db'
ORDER BY TABLE_NAME,
SCHEMA_NAME
LIMIT 5;
database_name | schema_name | table_name | table_type | table_acl | remarks
---------------+-------------+--------------------------+------------+-----------+---------
tickit_db | public | tickit_category_redshift | TABLE | |
tickit_db | public | tickit_date_redshift | TABLE | |
tickit_db | public | tickit_event_redshift | TABLE | |
tickit_db | public | tickit_listing_redshift | TABLE | |
tickit_db | public | tickit_sales_redshift | TABLE | |
```
如果 table\$1acl 值为 null，则没有显式授予针对相应表的访问权限。
# SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS
记录当前针对表的 Amazon Redshift Advisor 建议。此视图显示针对所有表的建议，无论它们是否为自动优化而定义。要查看某张表是否定义为自动优化，请参阅[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)。条目仅针对当前会话数据库中可见的表显示。在（Amazon Redshift 或您）应用建议后，该建议将不再显示在视图中。
SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ALTER_TABLE_RECOMMENDATIONS.html)
## 示例查询
在以下示例中，结果中的行显示分配键和排序键的建议。这些行还会显示这些建议是否有资格让 Amazon Redshift 自动应用它们。
```
select type, database, table_id, group_id, ddl, auto_eligible
from svv_alter_table_recommendations;
```
```
type | database | table_id | group_id | ddl | auto_eligible
diststyle | db0 | 117884 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f
diststyle | db0 | 117892 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f
diststyle | db0 | 117885 | 1 | ALTER TABLE "sch"."catalog_returns" ALTER DISTSTYLE KEY DISTKEY "cr_sold_date_sk", ALTER COMPOUND SORTKEY ("cr_sold_date_sk","cr_returned_time_sk") | t
sortkey | db0 | 117890 | -1 | ALTER TABLE "sch"."customer_addresses" ALTER COMPOUND SORTKEY ("ca_address_sk") | t
```
# SVV\$1ATTACHED\$1MASKING\$1POLICY
使用 SVV\$1ATTACHED\$1MASKING\$1POLICY 查看所有关系和已在当前连接的数据库上附加了策略的角色/用户。
只有拥有 [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) 角色的超级用户和用户才可以查看 SVV\$1ATTACHED\$1MASKING\$1POLICY。常规用户将看到 0 行。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ATTACHED_MASKING_POLICY.html)
## 内部函数
SVV\$1ATTACHED\$1MASKING\$1POLICY 支持以下内部函数：
### mask\$1get\$1policy\$1for\$1role\$1on\$1column
获取适用于给定列/角色对的最高优先级策略。
#### 语法
```
mask_get_policy_for_role_on_column
(relschema,
relname,
colname,
rolename);
```
#### 参数
*relschema*
策略所在 Schema 的名称。
*relname*
策略所在表的名称。
*colname*
策略所附加到的列的名称。
*rolename*
策略所附加到的角色的名称。
### mask\$1get\$1policy\$1for\$1user\$1on\$1column
获取适用于给定列/用户对的最高优先级策略。
#### 语法
```
mask_get_policy_for_user_on_column
(relschema,
relname,
colname,
username);
```
#### 参数
*relschema*
策略所在 Schema 的名称。
*relname*
策略所在表的名称。
*colname*
策略所附加到的列的名称。
*rolename*
策略所附加到的用户的名称。
# SVV\$1COLUMNS
使用 SVV\$1COLUMNS 查看有关本地和外部表及视图的列的目录信息，包括[后期绑定视图](r_CREATE_VIEW.md#r_CREATE_VIEW_late-binding-views)。
默认情况下，SVV\$1COLUMNS 对所有用户均可见。要控制对数据库元数据的访问，请为预置集群或无服务器工作组启用元数据安全性。元数据安全性可让您按用户和角色区分对象元数据的查看权限。有关更多信息，请参阅 [元数据安全性](t_metadata_security.md)。
SVV\$1COLUMNS 视图合并来自 [系统目录表](c_intro_catalog_views.md)（带 PG 前缀的表）和 [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md) 系统视图的表元数据。系统目录表描述 Amazon Redshift 数据库表。SVV\$1EXTERNAL\$1COLUMNS 描述与 Amazon Redshift Spectrum 结合使用的外部表。
所有用户均可查看系统目录表中的所有行。普通用户只能从其已被授予访问权限的外部表的“SVV\$1EXTERNAL\$1COLUMNS”视图中查看列定义。虽然普通用户可以在系统目录表中查看表元数据，但如果他们拥有表或已被授予访问权限，则他们只能从用户定义的表中选择数据。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_COLUMNS.html)
# SVV\$1COLUMN\$1PRIVILEGES
使用 SVV\$1COLUMN\$1PRIVILEGES 查看向当前数据库中的用户、角色和组显式授予的列权限。
SVV\$1COLUMN\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_COLUMN_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1COLUMN\$1PRIVILEGES 的结果。
```
SELECT namespace_name,relation_name,COLUMN_NAME,privilege_type,identity_name,identity_type
FROM svv_column_privileges WHERE relation_name = 'lineitem';
namespace_name | relation_name | column_name | privilege_type | identity_name | identity_type
----------------+---------------+-------------+----------------+---------------+----------------
public | lineitem | l_orderkey | SELECT | reguser | user
public | lineitem | l_orderkey | SELECT | role1 | role
public | lineitem | l_partkey | SELECT | reguser | user
public | lineitem | l_partkey | SELECT | role1 | role
```
# SVV\$1COPY\$1JOB\$1INTEGRATIONS
使用 SVV\$1COPY\$1JOB\$1INTEGRATIONS 可以查看 S3 事件集成的详细信息。
此视图包含已创建的 S3 事件集成。
SVV\$1COPY\$1JOB\$1INTEGRATIONS 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SVV_COPY_JOB_INTEGRATIONS.html)
以下示例返回当前数据库的 S3 集成。
```
SELECT * FROM SVV_COPY_JOB_INTEGRATIONS WHERE db_name = pg_catalog.current_database();
```
# SVV\$1DATABASE\$1PRIVILEGES
使用 SVV\$1DATABASE\$1PRIVILEGES 查看向 Amazon Redshift 集群中的用户、角色和组显式授予的数据库权限。
SVV\$1DATABASE\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DATABASE_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1DATABASE\$1PRIVILEGES 的结果。
```
SELECT database_name,privilege_type,identity_name,identity_type,admin_option FROM svv_database_privileges
WHERE database_name = 'test_db';
database_name | privilege_type | identity_name | identity_type | admin_option
---------------+----------------+---------------+---------------+--------------
test_db | CREATE | reguser | user | False
test_db | CREATE | role1 | role | False
test_db | TEMP | public | public | False
test_db | TEMP | role1 | role | False
```
# SVV\$1DATASHARE\$1PRIVILEGES
使用 SVV\$1DATASHARE\$1PRIVILEGES 查看向 Amazon Redshift 集群中的用户、角色和组显式授予的数据共享权限。
SVV\$1DATASHARE\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DATASHARE_PRIVILEGES.html)
## 示例查询
以下示例显示 SVV\$1DATASHARE\$1PRIVILEGES 的结果。
```
SELECT datashare_name,privilege_type,identity_name,identity_type,admin_option FROM svv_datashare_privileges
WHERE datashare_name = 'demo_share';
datashare_name | privilege_type | identity_name | identity_type | admin_option
----------------+----------------+----------------+---------------+--------------
demo_share | ALTER | superuser | user | False
demo_share | ALTER | reguser | user | False
```
# SVV\$1DATASHARES
使用 SVV\$1DATASHARES 可以查看在集群上创建的数据共享的列表，以及与集群共享的数据共享。
SVV\$1DATASHARES 对以下用户可见：
+ 超级用户
+ 数据共享拥有者
+ 对数据共享拥有 ALTER 或 USAGE 权限的用户
其他用户无法看到任何行。有关 ALTER 和 USAGE 权限的信息，请参阅[GRANT](r_GRANT.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DATASHARES.html)
## 使用说明
**检索其他元数据**：使用 `share_owner` 列中返回的整数时，您可以与 [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md) 中的 `usesysid` 进行联接，以获取有关数据共享所有者的数据。该数据包括名称和其他属性。
## 示例查询
以下示例返回 SVV\$1DATASHARES 的输出。
```
SELECT share_owner, source_database, share_type, is_publicaccessible
FROM svv_datashares
WHERE share_name LIKE 'tickit_datashare%'
AND source_database = 'dev';
share_owner | source_database | share_type | is_publicaccessible
--------------+-----------------+-------------+----------------------
100 | dev | OUTBOUND | True
(1 rows)
```
以下示例返回出站数据共享的 SVV\$1DATASHARES 的输出。
```
SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'OUTBOUND';
share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account| producer_namespace | managed_by
----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+-----------------+--------------------------------------+------------
salesshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
marketingshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
```
以下示例返回入站数据共享的 SVV\$1DATASHARES 的输出。
```
SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'INBOUND';
share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account | producer_namespace | managed_by
----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+------------------+--------------------------------------+------------
salesshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
marketingshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | ADX
```
# SVV\$1DATASHARE\$1CONSUMERS
使用 SVV\$1DATASHARE\$1CONSUMERS 可以查看在集群上创建的数据共享的使用者列表。
SVV\$1DATASHARE\$1CONSUMERS 对以下用户可见：
+ 超级用户
+ 数据共享拥有者
+ 对数据共享拥有 ALTER 或 USAGE 权限的用户
其他用户无法看到任何行。有关 ALTER 和 USAGE 权限的信息，请参阅[GRANT](r_GRANT.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DATASHARE_CONSUMERS.html)
## 示例查询
以下示例返回 SVV\$1DATASHARE\$1CONSUMERS 的输出。
```
SELECT count(*)
FROM svv_datashare_consumers
WHERE share_name LIKE 'tickit_datashare%';
1
```
# SVV\$1DATASHARE\$1OBJECTS
使用 SVV\$1DATASHARE\$1OBJECTS 可以查看在集群上创建或与集群共享的所有数据共享中的对象列表。
SVV\$1DATASHARE\$1OBJECTS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关查看数据共享列表的信息，请参阅 [SVV\$1DATASHARES](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_DATASHARES.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DATASHARE_OBJECTS.html)
## 示例查询
以下示例返回 SVV\$1DATASHARE\$1OBJECTS 的输出。
```
SELECT share_type,
btrim(share_name)::varchar(16) AS share_name,
object_type,
object_name
FROM svv_datashare_objects
WHERE share_name LIKE 'tickit_datashare%'
AND object_name LIKE '%tickit%'
ORDER BY object_name
LIMIT 5;
share_type | share_name | object_type | object_name
------------+--------------------+-------------+---------------------------------
OUTBOUND | tickit_datashare | table | public.tickit_category_redshift
OUTBOUND | tickit_datashare | table | public.tickit_date_redshift
OUTBOUND | tickit_datashare | table | public.tickit_event_redshift
OUTBOUND | tickit_datashare | table | public.tickit_listing_redshift
OUTBOUND | tickit_datashare | table | public.tickit_sales_redshift
```
```
SELECT * FROM SVV_DATASHARE_OBJECTS WHERE share_name like 'sales%';
share_type | share_name | object_type | object_name | producer_account | producer_namespace | include_new
-----------+------------+-------------+--------------+------------------+--------------------------------------+-------------
OUTBOUND | salesshare | schema | public | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | t
OUTBOUND | salesshare | table | public.sales | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
```
# SVV\$1DEFAULT\$1PRIVILEGES
使用 SVV\$1DEFAULT\$1PRIVILEGES 可查看用户在 Amazon Redshift 集群中有权访问的默认权限。
SVV\$1DEFAULT\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们获得的默认权限。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DEFAULT_PRIVILEGES.html)
## 示例查询
以下示例返回 SVV\$1DEFAULT\$1PRIVILEGES 的输出。
```
SELECT * from svv_default_privileges;
schema_name | object_type | owner_id | owner_name | owner_type | privilege_type | grantee_id | grantee_name | grantee_type | admin_option
-------------+-------------------+--------- +------------+------------+----------------+------------+--------------+--------------+-------------+
public | RELATION | 106 | u1 | user | UPDATE | 107 | u2 | user | f |
public | RELATION | 106 | u1 | user | SELECT | 107 | u2 | user | f |
```
# SVV\$1DISKUSAGE
Amazon Redshift 通过联接 STV\$1TBL\$1PERM 和 STV\$1BLOCKLIST 表来创建 SVV\$1DISKUSAGE 系统视图。SVV\$1DISKUSAGE 视图包含数据库中表的数据分配的相关信息。
针对 SVV\$1DISKUSAGE 使用聚合查询（如以下示例所示）可确定为每个数据库、表、切片或列分配的磁盘数据块的数目。每个数据块使用 1 MB。您还可以使用 [STV\$1PARTITIONS](r_STV_PARTITIONS.md) 查看有关磁盘利用率的摘要信息。
SVV\$1DISKUSAGE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_DISKUSAGE.html)
## 示例查询
分配的每个磁盘数据块在 SVV\$1DISKUSAGE 中对应一行，因此选择所有行的查询可能会返回非常多的行。建议仅对 SVV\$1DISKUSAGE 使用聚合查询。
返回曾经分配到 USERS 表中第 6 列（EMAIL 列）的最大数据块数。
```
select db_id, trim(name) as tablename, max(blocknum)
from svv_diskusage
where name='users' and col=6
group by db_id, name;
db_id | tablename | max
--------+-----------+-----
175857 | users | 2
(1 row)
```
对于名为 SALESNEW 的 10 列大型表中的所有列，下面的查询返回相似的结果。（列 10 到 12 的最后三行用于隐藏元数据列。）
```
select db_id, trim(name) as tablename, col, tbl, max(blocknum)
from svv_diskusage
where name='salesnew'
group by db_id, name, col, tbl
order by db_id, name, col, tbl;
db_id | tablename | col | tbl | max
--------+------------+-----+--------+-----
175857 | salesnew | 0 | 187605 | 154
175857 | salesnew | 1 | 187605 | 154
175857 | salesnew | 2 | 187605 | 154
175857 | salesnew | 3 | 187605 | 154
175857 | salesnew | 4 | 187605 | 154
175857 | salesnew | 5 | 187605 | 79
175857 | salesnew | 6 | 187605 | 79
175857 | salesnew | 7 | 187605 | 302
175857 | salesnew | 8 | 187605 | 302
175857 | salesnew | 9 | 187605 | 302
175857 | salesnew | 10 | 187605 | 3
175857 | salesnew | 11 | 187605 | 2
175857 | salesnew | 12 | 187605 | 296
(13 rows)
```
# SVV\$1EXTERNAL\$1COLUMNS
使用 SVV\$1EXTERNAL\$1COLUMNS 可查看外部表中列的详细信息。对于跨数据库查询，也可以使用 SVV\$1EXTERNAL\$1COLUMNS 来查看用户有权访问的未连接数据库上的表中所有列的详细信息。
SVV\$1EXTERNAL\$1COLUMNS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_EXTERNAL_COLUMNS.html)
# SVV\$1EXTERNAL\$1DATABASES
使用 SVV\$1EXTERNAL\$1DATABASES 可查看外部数据库的详细信息。
SVV\$1EXTERNAL\$1DATABASES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_EXTERNAL_DATABASES.html)
# SVV\$1EXTERNAL\$1PARTITIONS
使用 SVV\$1EXTERNAL\$1PARTITIONS 可查看外部表中分区的详细信息。
SVV\$1EXTERNAL\$1PARTITIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅[系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_EXTERNAL_PARTITIONS.html)
# SVV\$1EXTERNAL\$1SCHEMAS
使用 SVV\$1EXTERNAL\$1SCHEMAS 可查看有关外部 schema 的信息。有关更多信息，请参阅 [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。
SVV\$1EXTERNAL\$1SCHEMAS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_EXTERNAL_SCHEMAS.html)
## 示例
以下示例显示有关外部 schema 的详细信息。
```
select * from svv_external_schemas;
esoid | eskind | schemaname | esowner | databasename | esoptions
-------+--------+------------+---------+--------------+-------------------------------------------------------------
100133 | 1 | spectrum | 100 | redshift | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
```
# SVV\$1EXTERNAL\$1TABLES
使用 SVV\$1EXTERNAL\$1TABLES 可查看外部表的详细信息；有关更多信息，请参阅[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。对于跨数据库查询，也可以使用 SVV\$1EXTERNAL\$1TABLES 来查看用户有权访问的未连接数据库上的所有表的元数据。
SVV\$1EXTERNAL\$1TABLES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_EXTERNAL_TABLES.html)
## 示例
以下示例显示 svv\$1external\$1tables 详细信息以及联合查询使用的外部 schema 上的谓词。
```
select schemaname, tablename from svv_external_tables where schemaname = 'apg_tpch';
schemaname | tablename
------------+-----------
apg_tpch | customer
apg_tpch | lineitem
apg_tpch | nation
apg_tpch | orders
apg_tpch | part
apg_tpch | partsupp
apg_tpch | region
apg_tpch | supplier
(8 rows)
```
# SVV\$1FUNCTION\$1PRIVILEGES
使用 SVV\$1FUNCTION\$1PRIVILEGES 查看向当前数据库中的用户、角色和组显式授予的函数权限。
SVV\$1FUNCTION\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_FUNCTION_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1FUNCTION\$1PRIVILEGES 的结果。
```
SELECT namespace_name,function_name,argument_types,privilege_type,identity_name,identity_type,admin_option FROM svv_function_privileges
WHERE identity_name IN ('role1', 'reguser');
namespace_name | function_name | argument_types | privilege_type | identity_name | identity_type | admin_option
----------------+---------------+----------------------------+----------------+----------------+---------------+--------------
public | test_func1 | integer | EXECUTE | role1 | role | False
public | test_func2 | integer, character varying | EXECUTE | reguser | user | False
```
# SVV\$1GEOGRAPHY\$1COLUMNS
使用 SVV\$1GEOGRAPHY\$1COLUMNS 查看数据仓库中 GEOGRAPHY 列的列表。该列表包括来自数据共享的列。
SVV\$1GEOGRAPHY\$1COLUMNS 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_GEOGRAPHY_COLUMNS.html)
## 示例查询
以下示例显示了 SVV\$1GEOGRAPHY\$1COLUMNS 的结果。
```
SELECT * FROM svv_geography_columns;
f_table_catalog | f_table_schema | f_table_name | f_geography_column | coord_dimension | srid | type
-----------------+-----------------+---------------+---------------------+-----------------+------+--------------
dev | public | spatial_test | test_geography | 2 | 0 | GEOGRAPHY
```
# SVV\$1GEOMETRY\$1COLUMNS
使用 SVV\$1GEOMETRY\$1COLUMNS 查看数据仓库中 GEOMETRY 列的列表。该列表包括来自数据共享的列。
SVV\$1GEOMETRY\$1COLUMNS 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_GEOMETRY_COLUMNS.html)
## 示例查询
以下示例显示了 SVV\$1GEOMETRY\$1COLUMNS 的结果。
```
SELECT * FROM svv_geometry_columns;
f_table_catalog | f_table_schema | f_table_name | f_geometry_column | coord_dimension | srid | type
-----------------+-----------------+---------------+---------------------+-----------------+------+--------------
dev | public | accomodations | shape | 2 | 0 | GEOMETRY
dev | public | zipcode | wkb_geometry | 2 | 0 | GEOMETRY
```
# SVV\$1IAM\$1PRIVILEGES
使用 SVV\$1IAM\$1PRIVILEGES 查看向用户、角色和组显式授予的 IAM 权限。
SVV\$1IAM\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问的条目。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_IAM_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1IAM\$1PRIVILEGES 的结果。
```
SELECT * from SVV_IAM_PRIVILEGES ORDER BY IDENTITY_ID;
iam_arn | command_type | identity_id | identity_name | identity_type
----------------------+--------------+-------------+---------------+---------------
default-aws-iam-role | COPY | 0 | public | public
default-aws-iam-role | UNLOAD | 0 | public | public
default-aws-iam-role | CREATE MODEL | 0 | public | public
default-aws-iam-role | EXFUNC | 0 | public | public
default-aws-iam-role | COPY | 106 | u1 | user
default-aws-iam-role | UNLOAD | 106 | u1 | user
default-aws-iam-role | CREATE MODEL | 106 | u1 | user
default-aws-iam-role | EXFUNC | 106 | u1 | user
default-aws-iam-role | COPY | 118413 | r1 | role
default-aws-iam-role | UNLOAD | 118413 | r1 | role
default-aws-iam-role | CREATE MODEL | 118413 | r1 | role
default-aws-iam-role | EXFUNC | 118413 | r1 | role
(12 rows)
```
# SVV\$1IDENTITY\$1PROVIDERS
SVV\$1IDENTITY\$1PROVIDERS 视图返回身份提供商的名称和其他属性。有关如何创建身份提供商角色的更多信息，请参阅 [CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md)。
SVV\$1IDENTITY\$1PROVIDERS 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_IDENTITY_PROVIDERS.html)
### 示例查询
要查看身份提供商属性，请在创建身份提供商之后，运行类似以下内容的查询。
```
SELECT name, type, instanceid, namespc, params, enabled
FROM svv_identity_providers
ORDER BY 1;
```
示例输出包括 Microsoft Entra ID（以前称作 Azure AD）的参数描述：
```
name | type | instanceid | namespc | params | enabled
------------------+-------+--------------------------------------+---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------
rs5517_azure_idp | azure | e40d4bb2-7670-44ae-bfb8-5db013221d73 | abc | {"issuer":"https://login.microsoftonline.com/e40d4bb2-7670-44ae-bfb8-5db013221d73/v2.0", "client_id":"871c010f-5e61-4fb1-83ac-98610a7e9110", "client_secret":, "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift", "https://analysis.windows.net/powerbi/connector/AWSRDS"]} | t
(1 row)
```
示例输出包括 AWS IAM Identity Center 的参数描述：
```
name | type | instanceid | namespc | params | enabled
----------+--------+------------------------------------------------------------------------------------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+---------
idc_name | awsidc | arn:aws:sso::123456789012:application/ssoins-12345f67fe123d4/apl-a0b0a12dc123b1a4 | idc_namespc | {"iam_role":"arn:aws:iam::123456789012:role/MyRedshiftRole","instance_arn":"arn:aws:sso:::instance/ssoins-12345f67fe123d4","is_lakehouse_app":"true"} | t
(1 row)
```
# SVV\$1INTEGRATION
SVV\$1INTEGRATION 显示有关集成配置的详细信息。
SVV\$1INTEGRATION 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关零 ETL 集成的信息，请参阅[零 ETL 集成](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_INTEGRATION.html)
## 示例查询
以下 SQL 命令显示当前定义的集成。
```
select * from svv_integration;
integration_id | target_database | source | state | current_lag | last_replicated_checkpoint | total_tables_replicated | total_tables_failed | creation_time | refresh_interval | source_database | is_history_mode
---------------------------------------+-----------------+--------+-----------------+-------------+-------------------------------------+-------------------------+---------------------+---------------------------+--------------------+-----------------+-----------------
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | MySQL | CdcRefreshState | 56606106 | {"txn_seq":9834,"txn_id":126597515} | 152 | 0 | 2023-09-19 21:05:27.520299| 720 + mysourceetl | f
```
# SVV\$1INTEGRATION\$1TABLE\$1MAPPING
当源数据库、架构、表、列和数据类型与目标字段的标识符值不同时，SVV\$1INTEGRATION\$1TABLE\$1MAPPING 会显示源字段与目标字段之间的映射。
**注意**
仅针对以下类型的零 ETL 集成才填充此视图：
AWS Glue 第三方应用程序到 Amazon SageMaker 智能湖仓
Amazon DynamoDB 到 Amazon SageMaker 智能湖仓
有关更多信息，请参阅《AWS Glue 开发人员指南》**中的[零 ETL 集成](https://docs.aws.amazon.com/glue/latest/dg/zero-etl-using.html)。
标识符值从源到目标的转换遵循以下规则：
+ 大写字母会转换为小写。
+ 不是小写字母、数字或下划线（\$1）的字符将转换为下划线（\$1）。
+ 如果与现有标识符值存在冲突，则会在新标识符后面附加通用唯一标识符（UUID）。
+ 如果源标识符值是 Amazon Redshift 关键字，则会在新的标识符后面附加后缀 `_redshift`。
转换后，字符必须是小写字母、数字或下划线（\$1），并且必须与正则表达式模式 `[a-z0-9_]` 匹配。以下示例演示了转换规则：
| 来源 | Target | 备注 |
| --- | --- | --- |
| foo | foo | 无转换 |
| 条形图 | 条形图 | |
| fooBar | foobar | |
| foo1 | foo1 | 无转换 |
| foo\$11 | foo\$11 | 无转换 |
| Bar@1 | bar\$11 | |
| foo\$1bar@ | foo\$1bar\$1 | |
| 案例 | case\$1redshift | |
SVV\$1INTEGRATION\$1TABLE\$1MAPPING 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关零 ETL 集成的信息，请参阅《Amazon Redshift 管理指南》**中的[零 ETL 集成](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_MAPPING.html)
## 示例查询
以下 SQL 命令显示元数据值从源到目标的映射。
```
select * from svv_integration_table_mapping;
integration_id | source_database | target_database | source_schema_name | target_schema_name | source_table_name | target_table_name |
---------------------------------------+-----------------+-----------------+---------------------+--------------------+---------------------------------------+
99108e72-1cfd-414f-8cc0-0216acefac77 | mydatabase | mydatabase | myschema | myschema | Mytable | mytable |
| source_column_name | target_column_name | source_data_type | target_data_type |
+--------------------+--------------------+-------------------+------------------+
| Mycolumnname | mycolumnname | Mydatatype | mydatatype |
```
# SVV\$1INTEGRATION\$1TABLE\$1STATE
SVV\$1INTEGRATION\$1TABLE\$1STATE 显示有关表级集成信息的详情。
SVV\$1INTEGRATION\$1TABLE\$1STATE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关更多信息，请参阅 [Zero-ETL integrations](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html)
## 示例查询
以下 SQL 命令显示集成日志的列。
```
select * from svv_integration_table_state;
integration_id | target_database | schema_name | table_name | table_state |table_last_replicated_checkpoint | reason | last_updated_timestamp |table_rows | table_size | is_history_mode
--------------------------------------+-----------------+-------------+-------------------+--------------+---------------------------------+--------+----------------------------+------------+------------+-----------------
4798e675-8f9f-4686-b05f-92c538e19629 | sample_test2 | sample | SampleTestChannel | Synced | {"txn_seq":3,"txn_id":3122} | | 2023-05-12 12:40:30.656625 | 2 | 16 | f
```
# SVV\$1INTERLEAVED\$1COLUMNS
使用 SVV\$1INTERLEAVED\$1COLUMNS 视图可帮助确定使用交错排序键的表是否应使用 [VACUUM REINDEX](r_VACUUM_command.md#vacuum-reindex) 重建索引。有关如何确定运行 VACUUM 的频度和运行 VACUUM REINDEX 的时机的更多信息，请参阅[最大程度地减少 vacuum 次数](vacuum-managing-vacuum-times.md)。
SVV\$1INTERLEAVED\$1COLUMNS 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_INTERLEAVED_COLUMNS.html)
## 示例查询
要找出可能需要重建索引的表，请运行下面的查询。
```
select tbl as tbl_id, stv_tbl_perm.name as table_name,
col, interleaved_skew, last_reindex
from svv_interleaved_columns, stv_tbl_perm
where svv_interleaved_columns.tbl = stv_tbl_perm.id
and interleaved_skew is not null;
tbl_id | table_name | col | interleaved_skew | last_reindex
--------+------------+-----+------------------+--------------------
100068 | lineorder | 0 | 3.65 | 2015-04-22 22:05:45
100068 | lineorder | 1 | 2.65 | 2015-04-22 22:05:45
100072 | customer | 0 | 1.65 | 2015-04-22 22:05:45
100072 | lineorder | 1 | 1.00 | 2015-04-22 22:05:45
(4 rows)
```
# SVV\$1LANGUAGE\$1PRIVILEGES
使用 SVV\$1LANGUAGE\$1PRIVILEGES 查看向当前数据库中的用户、角色和组显式授予的语言权限。
SVV\$1LANGUAGE\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_LANUGAGE_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1LANGUAGE\$1PRIVILEGES 的结果。
```
SELECT language_name,privilege_type,identity_name,identity_type,admin_option FROM svv_language_privileges
WHERE identity_name IN ('role1', 'reguser');
language_name | privilege_type | identity_name | identity_type | admin_option
---------------+----------------+---------------+---------------+---------------
exfunc | USAGE | reguser | user | False
exfunc | USAGE | role1 | role | False
plpythonu | USAGE | reguser | user | False
```
# SVV\$1MASKING\$1POLICY
使用 SVV\$1MASKING\$1POLICY 查看在集群上创建的所有屏蔽策略。
只有拥有 [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) 角色的超级用户和用户才可以查看 SVV\$1MASKING\$1POLICY。常规用户将看到 0 行。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_MASKING_POLICY.html)
# SVV\$1ML\$1MODEL\$1INFO
有关机器学习模型当前状态的状态信息。
SVV\$1ML\$1MODEL\$1INFO 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ML_MODEL_INFO.html)
## 示例查询
以下查询显示机器学习模型的当前状态。
```
SELECT schema_name, model_name, model_state
FROM svv_ml_model_info;
schema_name | model_name | model_state
-------------+------------------------------+--------------------------------------
public | customer_churn_auto_model | Train Model On SageMaker In Progress
public | customer_churn_xgboost_model | Model is Ready
(2 row)
```
# SVV\$1ML\$1MODEL\$1PRIVILEGES
使用 SVV\$1ML\$1MODEL\$1PRIVILEGES 查看向集群中的用户、角色和组显式授予的机器学习模型权限。
SVV\$1ML\$1MODEL\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ML_MODEL_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1ML\$1MODEL\$1PRIVILEGES 的结果。
```
SELECT namespace_name,model_name,model_version,privilege_type,identity_name,identity_type,admin_option FROM svv_ml_model_privileges
WHERE model_name = 'test_model';
namespace_name | model_name | model_version | privilege_type | identity_name | identity_type | admin_option
----------------+------------+---------------+----------------+----------------+---------------+--------------
public | test_model | 1 | EXECUTE | reguser | user | False
public | test_model | 1 | EXECUTE | role1 | role | False
```
# SVV\$1MV\$1DEPENDENCY
SVV\$1MV\$1DEPENDENCY 表显示了实体化视图与 Amazon Redshift 内其他实体化视图的依赖关系。
有关实体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
SVV\$1MV\$1DEPENDENCY 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_MV_DEPENDENCY.html)
## 示例查询
以下查询返回一个输出行，该行指示具体化视图 `mv_over_foo` 在其定义中使用具体化视图 `mv_foo` 作为二依赖项。
```
CREATE SCHEMA test_ivm_setup;
CREATE TABLE test_ivm_setup.foo(a INT);
CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo;
CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo;
SELECT * FROM svv_mv_dependency;
database_name | schema_name | name | dependent_database_name | dependent_schema_name | dependent_name
---------------+----------------------+-------------+-------------------------+---------------------------+----------
dev | test_ivm_setup | mv_over_foo | dev | test_ivm_setup | mv_foo
```
# SVV\$1MV\$1INFO
SVV\$1MV\$1INFO 表针对每个实体化视图、数据是否陈旧以及状态信息包含一行。
有关实体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
SVV\$1MV\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_MV_INFO.html)
## 示例查询
要查看所有实体化视图的状态，请运行以下查询。
```
select * from svv_mv_info;
```
此查询返回以下示例输出。
```
database_name | schema_name | user_name | name | is_stale | state | autorefresh | autorewrite
--------------+-------------------------+-----------+---------+-----------+-------+-------------+----------------
dev | test_ivm_setup | catch-22 | mv | f | 1 | 1 | 0
dev | test_ivm_setup | lotr | old_mv | t | 1 | 0 | 1
```
# SVV\$1QUERY\$1INFLIGHT
使用 SVV\$1QUERY\$1INFLIGHT 视图可以确定当前正在对数据库运行的查询。此视图将 [STV\$1INFLIGHT](r_STV_INFLIGHT.md) 联接到 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)。SVV\$1QUERY\$1INFLIGHT 不会显示仅领导节点查询。有关更多信息，请参阅 [仅领导节点函数](c_SQL_functions_leader_node_only.md)。
SVV\$1QUERY\$1INFLIGHT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_QUERY_INFLIGHT.html)
## 示例查询
下面的示例输出显示了两个当前正在运行的查询：SVV\$1QUERY\$1INFLIGHT 查询本身及查询 428（分成该表中的三行）。（在本示例输出中，starttime 和 statement 列被截断了。）
```
select slice, query, pid, starttime, suspended, trim(text) as statement, sequence
from svv_query_inflight
order by query, sequence;
slice|query| pid | starttime |suspended| statement | sequence
-----+-----+------+----------------------+---------+-----------+---------
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | select ...| 0
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | enueid ...| 1
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | atname,...| 2
1012 | 429 | 1608 | 2012-04-10 13:53:... | 0 | select ...| 0
(4 rows)
```
# SVV\$1QUERY\$1STATE
使用 SVV\$1QUERY\$1STATE 查看有关当前正在运行的查询的运行时信息。
SVV\$1QUERY\$1STATE 视图包含 STV\$1EXEC\$1STATE 表的数据子集。
SVV\$1QUERY\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_QUERY_STATE.html)
## 示例查询
**按步骤确定查询的处理时间**
下面的查询显示查询 ID 为 279 的查询每一步的运行时长以及 Amazon Redshift 处理的数据行数：
```
select query, seg, step, maxtime, avgtime, rows, label
from svv_query_state
where query = 279
order by query, seg, step;
```
此查询检索有关查询 279 的处理信息，如下面的示例输出所示：
```
query | seg | step | maxtime | avgtime | rows | label
------+---------+------+---------+---------+---------+-------------------
279 | 3 | 0 | 1658054 | 1645711 | 1405360 | scan
279 | 3 | 1 | 1658072 | 1645809 | 0 | project
279 | 3 | 2 | 1658074 | 1645812 | 1405434 | insert
279 | 3 | 3 | 1658080 | 1645816 | 1405437 | distribute
279 | 4 | 0 | 1677443 | 1666189 | 1268431 | scan
279 | 4 | 1 | 1677446 | 1666192 | 1268434 | insert
279 | 4 | 2 | 1677451 | 1666195 | 0 | aggr
(7 rows)
```
**确定当前是否在磁盘上运行任何事件查询**
下面的查询显示磁盘上有没有任何当前正在运行的活动查询：
```
select query, label, is_diskbased from svv_query_state
where is_diskbased = 't';
```
此示例输出显示磁盘上当前正在运行的任何活动查询：
```
query | label | is_diskbased
-------+--------------+--------------
1025 | hash tbl=142 | t
(1 row)
```
# SVV\$1REDSHIFT\$1COLUMNS
使用 SVV\$1REDSHIFT\$1COLUMNS 可以查看用户有权访问的所有列的列表。这组列包括集群上的列和远程集群提供的数据共享中的列。
SVV\$1REDSHIFT\$1COLUMNS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_COLUMNS.html)
## 示例查询
下面的示例返回 SVV\$1REDSHIFT\$1COLUMNS 的输出。
```
SELECT *
FROM svv_redshift_columns
WHERE database_name = 'tickit_db'
AND TABLE_NAME = 'tickit_sales_redshift'
ORDER BY COLUMN_NAME,
TABLE_NAME,
database_name
LIMIT 5;
database_name | schema_name | table_name | column_name | ordinal_position | data_type | column_default | is_nullable | encoding | distkey | sortkey | column_acl | remarks
--------------+-------------+-----------------------+-------------+------------------+-----------+----------------+-------------+----------+---------+---------+-------------+--------
tickit_db | public | tickit_sales_redshift | buyerid | 4 | integer | | NO | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | commission | 9 | numeric | (8,2) | YES | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | dateid | 6 | smallint | | NO | none | False | 1 | |
tickit_db | public | tickit_sales_redshift | eventid | 5 | integer | | NO | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | listid | 2 | integer | | NO | az64 | True | 0 | |
```
# SVV\$1REDSHIFT\$1DATABASES
使用 SVV\$1 REDSHIFT\$1DATABASES 可以查看用户有权访问的所有数据库的列表。这包括集群上的数据库以及从远程集群提供的数据共享创建的数据库。
默认情况下，SVV\$1REDSHIFT\$1DATABASES 对所有用户均可见。要控制对数据库元数据的访问，请为预置集群或无服务器工作组启用元数据安全性。元数据安全性可让您按用户和角色区分对象元数据的查看权限。有关更多信息，请参阅 [元数据安全性](t_metadata_security.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_DATABASES.html)
## 示例查询
以下示例返回 SVV\$1REDSHIFT\$1DATABASES 的输出。
```
select database_name, database_owner, database_type, database_options, database_isolation_level
from svv_redshift_databases;
database_name | database_owner | database_type | database_options | database_isolation_level
--------------+----------------+---------------+------------------+------------------
dev | 1 | local | NULL | Serializable
```
# SVV\$1REDSHIFT\$1FUNCTIONS
使用 SVV\$1REDSHIFT\$1FUNCTIONS 查看用户有权访问的所有函数的列表。这组函数包括集群上的函数和远程集群提供的数据共享中的函数。
SVV\$1REDSHIFT\$1FUNCTIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_FUNCTIONS.html)
## 示例查询
下面的示例返回 SVV\$1REDSHIFT\$1FUNCTIONS 的输出。
```
SELECT *
FROM svv_redshift_functions
WHERE database_name = 'tickit_db'
AND SCHEMA_NAME = 'public'
ORDER BY function_name
LIMIT 5;
database_name | schema_name | function_name | function_type | argument_type | result_type
--------------+-------------+-----------------------+------------------+------------------+-------------
tickit_db | public | shared_function | REGULAR FUNCTION | integer, integer | integer
```
# SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA
显示数据库中每个模式的限额和当前磁盘使用情况。
SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
当查询预调配集群或 Redshift Serverless 工作组时，此视图可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMA_QUOTA.html)
## 示例查询
以下示例显示名为 `sales_schema` 的模式的限额和当前磁盘使用情况。
```
SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage FROM svv_redshift_schema_quota
WHERE SCHEMA_NAME = 'sales_schema';
schema_name | quota | disk_usage
--------------+-------+------------
sales_schema | 2048 | 30
```
# SVV\$1REDSHIFT\$1SCHEMAS
使用 SVV\$1REDSHIFT\$1SCHEMAS 可以查看用户有权访问的所有 schema 的列表。这组 schema 包括集群上的 schema 和远程集群提供的数据共享中的 schema。
SVV\$1REDSHIFT\$1SCHEMAS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMAS.html)
## 示例查询
下面的示例返回 SVV\$1REDSHIFT\$1SCHEMAS 的输出。
```
SELECT *
FROM svv_redshift_schemas
WHERE database_name = 'tickit_db'
ORDER BY database_name,
SCHEMA_NAME;
database_name | schema_name | schema_owner | schema_type | schema_acl | schema_option
--------------+--------------------+--------------+-------------+------------+---------------
tickit_db | public | 1 | shared | |
```
# SVV\$1REDSHIFT\$1TABLES
使用 SVV\$1REDSHIFT\$1TABLES 可以查看用户有权访问的所有表的列表。这组表包括集群上的表和远程集群提供的数据共享中的表。
SVV\$1REDSHIFT\$1TABLES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_REDSHIFT_TABLES.html)
## 示例查询
下面的示例返回 SVV\$1REDSHIFT\$1TABLES 的输出。
```
SELECT *
FROM svv_redshift_tables
WHERE database_name = 'tickit_db' AND TABLE_NAME LIKE 'tickit_%'
ORDER BY database_name,
TABLE_NAME;
database_name | schema_name | table_name | table_type | table_acl | remarks | table_owner
--------------+-------------+--------------------------+------------+-----------+---------+-----------
tickit_db | public | tickit_category_redshift | TABLE | | +
tickit_db | public | tickit_date_redshift | TABLE | | +
tickit_db | public | tickit_event_redshift | TABLE | | +
tickit_db | public | tickit_listing_redshift | TABLE | | +
tickit_db | public | tickit_sales_redshift | TABLE | | +
tickit_db | public | tickit_users_redshift | TABLE | | +
tickit_db | public | tickit_venue_redshift | TABLE | |
```
如果 table\$1acl 值为 null，则没有显式授予针对相应表的访问权限。
# SVV\$1RELATION\$1PRIVILEGES
使用 SVV\$1RELATION\$1PRIVILEGES 查看向当前数据库中的用户、角色和组显式授予的关系（表和视图）权限。
SVV\$1RELATION\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 SYSLOG ACCESS UNRESTRICTED 权限的用户
其他用户只能看到他们有权访问或拥有的身份。有关数据可见性的更多信息，请参阅[系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_RELATION_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1RELATION\$1PRIVILEGES 的结果。
```
SELECT namespace_name,relation_name,privilege_type,identity_name,identity_type,admin_option FROM svv_relation_privileges
WHERE relation_name = 'orders' AND privilege_type = 'SELECT';
namespace_name | relation_name | privilege_type | identity_name | identity_type | admin_option
----------------+---------------+----------------+----------------+---------------+--------------
public | orders | SELECT | reguser | user | False
public | orders | SELECT | role1 | role | False
```
# SVV\$1RLS\$1APPLIED\$1POLICY
使用 SVV\$1RLS\$1APPLIED\$1POLICY 跟踪 RLS 策略在引用受 RLS 保护的关系的查询上的应用情况。
SVV\$1RLS\$1APPLIED\$1POLICY 对以下用户可见：
+ 超级用户
+ 拥有 `sys:operator` 角色的用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
请注意，sys:secadmin 未被授予此系统权限。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_RLS_APPLIED_POLICY.html)
## 示例查询
以下示例显示了 SVV\$1RLS\$1APPLIED\$1POLICY 的结果。要查询 SVV\$1RLS\$1APPLIED\$1POLICY，您必须拥有 ACCESS SYSTEM TABLE 权限。
```
-- Check what RLS policies were applied to the run query.
SELECT username, command, datname, relschema, relname, polname, poldefault
FROM svv_rls_applied_policy
WHERE datname = CURRENT_DATABASE() AND query = PG_LAST_QUERY_ID();
username | command | datname | relschema | relname | polname | poldefault
----------+---------+-----------+-----------+--------------------------+-----------------+------------
molly | s | tickit_db | public | tickit_category_redshift | policy_concerts |
```
# SVV\$1RLS\$1ATTACHED\$1POLICY
使用 SVV\$1RLS\$1ATTACHED\$1POLICY 以查看已在当前连接的数据库上附加了一个或多个行级别安全性策略的所有关系和用户的列表。
只有拥有 sys:secadmin 角色的用户才能查询此视图。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_RLS_ATTACHED_POLICY.html)
## 示例查询
以下示例显示了 SVV\$1RLS\$1ATTACHED\$1POLICY 的结果。
```
--Inspect the policy in SVV_RLS_ATTACHED_POLICY
SELECT * FROM svv_rls_attached_policy;
relschema | relname | relkind | polname | grantor | grantee | granteekind | is_pol_on | is_rls_on | rls_conjuntion_type
-----------+--------------------------+---------+-----------------+---------+----------+-------------+-----------+-----------+---------------------
public | tickit_category_redshift | table | policy_concerts | bob | analyst | role | True | True | and
public | tickit_category_redshift | table | policy_concerts | bob | dbadmin | role | True | True | and
```
# SVV\$1RLS\$1POLICY
使用 SVV\$1RLS\$1POLICY 以查看在 Amazon Redshift 集群上创建的所有行级别安全性策略的列表。
SVV\$1RLS\$1POLICY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_RLS_POLICY.html)
## 示例查询
以下示例显示了 SVV\$1RLS\$1POLICY 的结果。
```
-- Create some policies.
CREATE RLS POLICY pol1 WITH (a int) AS t USING ( t.a IS NOT NULL );
CREATE RLS POLICY pol2 WITH (c varchar(10)) AS t USING ( c LIKE '%public%');
-- Inspect the policy in SVV_RLS_POLICY
SELECT * FROM svv_rls_policy;
poldb | polname | polalias | polatts | polqual | polenabled | polmodifiedby | polmodifiedtime
-------+---------+----------+--------------------------------------------------+---------------------------------------+------------+---------------+---------------------
my_db | pol1 | t | [{"colname":"a","type":"integer"}] | "t"."a" IS NOT NULL | t | policy_admin | 2022-02-11 14:40:49
my_db | pol2 | t | [{"colname":"c","type":"character varying(10)"}] | "t"."c" LIKE CAST('%public%' AS TEXT) | t | policy_admin | 2022-02-11 14:41:28
```
# SVV\$1RLS\$1RELATION
使用 SVV\$1RLS\$1RELATION 以查看受 RLS 保护的所有关系的列表。
SVV\$1RLS\$1RELATION 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_RLS_RELATION.html)
## 示例查询
以下示例显示了 SVV\$1RLS\$1RELATION 的结果。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON FOR DATASHARES;
--Inspect RLS state on the relations using SVV_RLS_RELATION.
SELECT datname, relschema, relname, relkind, is_rls_on, is_rls_datashare_on FROM svv_rls_relation ORDER BY relname;
datname | relschema | relname | relkind | is_rls_on | is_rls_datashare_on | rls_conjunction_type | rls_datashare_conjunction_type
-----------+-----------+--------------------------+---------+-----------+---------------------+----------------------+--------------------------------
tickit_db | public | tickit_category_redshift | table | t | t | and | and
(1 row)
```
# SVV\$1ROLE\$1GRANTS
使用 SVV\$1ROLE\$1GRANTS 查看在集群中显式授予的角色的角色列表。
SVV\$1ROLE\$1GRANTS 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ROLE_GRANTS.html)
## 示例查询
以下示例将返回 SVV\$1ROLE\$1GRANTS 的输出。
```
GRANT ROLE role1 TO ROLE role2;
GRANT ROLE role2 TO ROLE role3;
SELECT role_name, granted_role_name FROM svv_role_grants;
role_name | granted_role_name
-----------+--------------------
role2 | role1
role3 | role2
(2 rows)
```
# SVV\$1ROLES
使用 SVV\$1ROLES 查看角色信息。
此表对所有用户可见。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_ROLES.html)
## 示例查询
以下示例将返回 SVV\$1ROLES 的输出。
```
SELECT role_name,role_owner FROM svv_roles WHERE role_name IN ('role1', 'role2');
role_name | role_owner
-----------+------------
role1 | superuser
role2 | superuser
```
# SVV\$1SCHEMA\$1PRIVILEGES
使用 SVV\$1SCHEMA\$1PRIVILEGES 查看向当前数据库中的用户、角色和组显式授予的 Schema 权限。
SVV\$1SCHEMA\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_SCHEMA_PRIVILEGES.html)
## 示例查询
以下示例显示了 SVV\$1SCHEMA\$1PRIVILEGES 的结果。
```
SELECT namespace_name,privilege_type,identity_name,identity_type,admin_option FROM svv_schema_privileges
WHERE namespace_name = 'test_schema1';
namespace_name | privilege_type | identity_name | identity_type | admin_option
----------------+----------------+----------------+---------------+--------------
test_schema1 | USAGE | reguser | user | False
test_schema1 | USAGE | role1 | role | False
```
# SVV\$1SCHEMA\$1QUOTA\$1STATE
显示每个 schema 的配额和当前磁盘使用情况。
普通用户可以查看其拥有 USAGE 权限的 schema 的信息。超级用户可以查看当前数据库中所有 schema 的信息。
SVV\$1SCHEMA\$1QUOTA\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_SCHEMA_QUOTA_STATE.html)
## 示例查询
以下示例显示 schema 的配额和当前磁盘使用情况。
```
SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage, disk_usage_pct FROM svv_schema_quota_state
WHERE SCHEMA_NAME = 'sales_schema';
schema_name | quota | disk_usage | disk_usage_pct
--------------+-------+------------+----------------
sales_schema | 2048 | 30 | 1.46
(1 row)
```
# SVV\$1SYSTEM\$1PRIVILEGES
SVV\$1SYSTEM\$1PRIVILEGES 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到他们有权访问或拥有的身份。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_SYSTEM_PRIVILEGES.html)
## 示例查询
以下示例显示了指定参数的结果。
```
SELECT system_privilege,identity_name,identity_type FROM svv_system_privileges
WHERE system_privilege = 'ALTER TABLE' AND identity_name = 'sys:superuser';
system_privilege | identity_name | identity_type
------------------+---------------+---------------
ALTER TABLE | sys:superuser | role
```
# SVV\$1TABLE\$1INFO
显示当前已连接数据库中的表和实体化视图的摘要信息。该视图筛选出系统表，并且仅显示用户定义的表和实体化视图（包含至少 1 行数据）。
您可以使用 SVV\$1TABLE\$1INFO 视图来诊断和解决可能影响查询性能的表设计问题。这包括压缩编码、分配键、排序方式、数据分配偏斜、表大小和统计数据等方面的问题。SVV\$1TABLE\$1INFO 视图对于空表不返回任何信息。
SVV\$1TABLE\$1INFO 视图汇总了以下系统表和目录表中的信息：
+ [STV\$1NODE\$1STORAGE\$1CAPACITY](r_STV_NODE_STORAGE_CAPACITY.md)
+ [STV\$1SLICES](r_STV_SLICES.md)
+ [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)
+ [PG\$1ATTRIBUTE](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html)
+ [PG\$1CLASS](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html)
+ [PG\$1DATABASE](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html)
+ [PG\$1NAMESPACE](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html)
+ [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md)
SVV\$1TABLE\$1INFO 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。要允许用户查询视图，请向该用户授予 SVV\$1TABLE\$1INFO 上的 SELECT 权限。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_TABLE_INFO.html)
## 示例查询
下面的示例显示数据库中所有用户定义的表的编码、分配方式、排序和数据偏斜。其中，“table”是一个保留字，因此必须用双引号括起来。
```
select "table", encoded, diststyle, sortkey1, skew_sortkey1, skew_rows
from svv_table_info
order by 1;
table | encoded | diststyle | sortkey1 | skew_sortkey1 | skew_rows
---------------+---------+-----------------+--------------+---------------+----------
category | N | EVEN | | |
date | N | ALL | dateid | 1.00 |
event | Y | KEY(eventid) | dateid | 1.00 | 1.02
listing | Y | KEY(listid) | dateid | 1.00 | 1.01
sales | Y | KEY(listid) | dateid | 1.00 | 1.02
users | Y | KEY(userid) | userid | 1.00 | 1.01
venue | N | ALL | venueid | 1.00 |
(7 rows)
```
# SVV\$1TABLES
使用 SVV\$1TABLES 查看本地和外部目录中的表。
默认情况下，SVV\$1TABLES 对所有用户均可见。要控制对数据库元数据的访问，请为预置集群或无服务器工作组启用元数据安全性。元数据安全性可让您按用户和角色区分对象元数据的查看权限。有关更多信息，请参阅 [元数据安全性](t_metadata_security.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_TABLES.html)
# SVV\$1TRANSACTIONS
记录当前锁定到数据库中的表的事务的相关信息。使用 SVV\$1TRANSACTIONS 视图可标识未结事务和锁定争用问题。有关锁定的更多信息，请参阅[管理并发写入操作](c_Concurrent_writes.md)和[LOCK](r_LOCK.md)。
SVV\$1TRANSACTIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_TRANSACTIONS.html)
## 示例查询
以下命令显示所有活动事务和每个事务请求的锁定。
```
select * from svv_transactions;
txn_ lockable_
owner | txn_db | xid | pid | txn_start | lock_mode | object_type | relation | granted
-------+--------+--------+-------+----------------------------+---------------------+----------------+----------+---------
root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | AccessShareLock | relation | 100068 | t
root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | ExclusiveLock | transactionid | | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 50860 | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 52310 | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | ExclusiveLock | transactionid | | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100068 | f
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | RowExclusiveLock | relation | 16688 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessShareLock | relation | 100064 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100166 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100171 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100190 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | ExclusiveLock | transactionid | | t
(12 rows)
(12 rows)
```
# SVV\$1USER\$1GRANTS
使用 SVV\$1USER\$1GRANTS 查看在集群中被显式授予了角色的用户列表。
SVV\$1USER\$1GRANTS 对以下用户可见：
+ 超级用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
其他用户只能看到明确授予给他们的角色。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_USER_GRANTS.html)
## 示例查询
以下查询将向用户授予角色并显示被显式授予了角色的用户列表。
```
GRANT ROLE role1 TO reguser;
GRANT ROLE role2 TO reguser;
GRANT ROLE role1 TO superuser;
GRANT ROLE role2 TO superuser;
SELECT user_name,role_name,admin_option FROM svv_user_grants;
user_name | role_name | admin_option
-----------+-----------+--------------
superuser | role1 | False
reguser | role1 | False
superuser | role2 | False
reguser | role2 | False
```
# SVV\$1USER\$1INFO
您可以使用 SVV\$1USER\$1INFO 视图检索有关 Amazon Redshift 数据库用户的数据。
SVV\$1USER\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_USER_INFO.html)
## 示例查询
以下命令从 SVV\$1USER\$1INFO 检索用户信息。
```
SELECT * FROM SVV_USER_INFO;
```
# SVV\$1VACUUM\$1PROGRESS
此视图返回完成当前正在执行的 vacuum 操作的估算时间。
SVV\$1VACUUM\$1PROGRESS 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
有关 SVV\$1VACUUM\$1SUMMARY 的信息，请参阅 [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md)。
有关 SVL\$1VACUUM\$1PERCENTAGE 的信息，请参阅 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_VACUUM_PROGRESS.html)
## 示例查询
以下查询（隔几分钟运行）显示正在对名为 SALESNEW 的大型表执行 vacuum 操作。
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
--------------+-------------------------------+-------------------------
salesnew | Vacuum: initialize salesnew |
(1 row)
...
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+------------------------+-------------------------
salesnew | Vacuum salesnew sort | 33m 21s
(1 row)
```
下面的查询显示当前没有正在执行的 vacuum 操作。最近一次执行 vacuum 操作的表是 SALES 表。
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+----------+-------------------------
sales | Complete |
(1 row)
```
# SVV\$1VACUUM\$1SUMMARY
SVV\$1VACUUM\$1SUMMARY 视图联接 STL\$1VACUUM、STL\$1QUERY、STV\$1TBL\$1PERM 表，以汇总系统记录的 vacuum 操作的信息。该视图每个 vacuum 事务每张表返回一行。该视图记录操作执行前后的用时、所创建的排序分区的数量、需要的合并增量的数量以及行和数据块计数中的增量。
SVV\$1VACUUM\$1SUMMARY 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
有关 SVV\$1VACUUM\$1PROGRESS 的信息，请参阅 [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md)。
有关 SVL\$1VACUUM\$1PERCENTAGE 的信息，请参阅 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)。
**注意**
此视图仅在查询预置集群时可用。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVV_VACUUM_SUMMARY.html)
## 示例查询
下面的查询返回三个不同的表的 vacuum 操作的统计数据。SALES 表执行了两次 vacuum 操作。
```
select table_name, xid, sort_partitions as parts, merge_increments as merges,
elapsed_time, row_delta, sortedrow_delta as sorted_delta, block_delta
from svv_vacuum_summary
order by xid;
table_ | xid |parts|merges| elapsed_ | row_ | sorted_ | block_
name | | | | time | delta | delta | delta
--------+------+-----+------+----------+---------+---------+--------
users | 2985 | 1 | 1 | 61919653 | 0 | 49990 | 20
category| 3982 | 1 | 1 | 24136484 | 0 | 11 | 0
sales | 3992 | 2 | 1 | 71736163 | 0 | 1207192 | 32
sales | 4000 | 1 | 1 | 15363010 | -851648 | -851648 | -140
(4 rows)
```
# SYS 监控视图
*监控视图*是 Amazon Redshift 中用于监控预置集群和无服务器工作组的查询和工作负载资源使用情况的系统视图。这些视图位于 `pg_catalog` 架构中。要显示这些视图提供的信息，请运行 SQL SELECT 语句。
除非另有说明，否则这些视图适用于 Amazon Redshift 集群和 Amazon Redshift Serverless 工作组。
*SYS\$1SERVERLESS\$1USAGE* 仅会收集 Amazon Redshift Serverless 的使用情况数据。
**Topics**
+ [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md)
+ [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md)
+ [SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG](SYS_APPLIED_MASKING_POLICY_LOG.md)
+ [SYS\$1AUTOMATIC\$1OPTIMIZATION](SYS_AUTOMATIC_OPTIMIZATION.md)
+ [SYS\$1AUTO\$1TABLE\$1OPTIMIZATION](r_SYS_AUTO_TABLE_OPTIMIZATION.md)
+ [SYS\$1CHILD\$1QUERY\$1TEXT](SYS_CHILD_QUERY_TEXT.md)
+ [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md)
+ [SYS\$1COPY\$1JOB](SYS_COPY_JOB.md)
+ [SYS\$1COPY\$1JOB\$1DETAIL](SYS_COPY_JOB_DETAIL.md)
+ [SYS\$1COPY\$1JOB\$1INFO](SYS_COPY_JOB_INFO.md)
+ [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md)
+ [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md)
+ [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md)
+ [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md)
+ [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md)
+ [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)
+ [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md)
+ [SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION](SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.md)
+ [SYS\$1INTEGRATION\$1ACTIVITY](r_SYS_INTEGRATION_ACTIVITY.md)
+ [SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY](r_SYS_INTEGRATION_TABLE_ACTIVITY.md)
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](r_SYS_INTEGRATION_TABLE_STATE_CHANGE.md)
+ [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)
+ [SYS\$1LUDF\$1DETAIL](SYS_LUDF_DETAIL.md)
+ [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)
+ [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md)
+ [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md)
+ [SYS\$1MV\$1STATE](SYS_MV_STATE.md)
+ [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md)
+ [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md)
+ [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)
+ [SYS\$1QUERY\$1EXPLAIN](SYS_QUERY_EXPLAIN.md)
+ [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)
+ [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md)
+ [SYS\$1REDSHIFT\$1TEMPLATE](SYS_REDSHIFT_TEMPLATE.md)
+ [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md)
+ [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md)
+ [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md)
+ [SYS\$1SERVERLESS\$1USAGE](SYS_SERVERLESS_USAGE.md)
+ [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md)
+ [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md)
+ [SYS\$1STREAM\$1SCAN\$1ERRORS](r_SYS_STREAM_SCAN_ERRORS.md)
+ [SYS\$1STREAM\$1SCAN\$1STATES](r_SYS_STREAM_SCAN_STATES.md)
+ [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md)
+ [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md)
+ [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md)
+ [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md)
+ [SYS\$1USERLOG](SYS_USERLOG.md)
+ [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)
# SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
记录在 COPY 或 ANALYZE COMPRESSION 命令期间压缩分析操作的详细信息。
SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_ANALYZE_COMPRESSION_HISTORY.html)
## 示例查询
以下示例检查在同一个会话中运行的最后一个 COPY 命令对 `lineitem` 表执行压缩分析的详细信息。
```
select transaction_id, table_id, btrim(table_name) as table_name, column_position, old_encoding, new_encoding, mode
from sys_analyze_compression_history
where transaction_id = (select transaction_id from sys_query_history where query_id = pg_last_copy_id()) order by column_position;
transaction_id | table_id | table_name | column_position | old_encoding | new_encoding | mode
-----------------+-------------+------------+-----------------+-----------------+-----------------+-------------
8196 | 248126 | lineitem | 0 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 1 | mostly32 | lzo | ON
8196 | 248126 | lineitem | 2 | lzo | delta32k | ON
8196 | 248126 | lineitem | 3 | delta | delta | ON
8196 | 248126 | lineitem | 4 | bytedict | bytedict | ON
8196 | 248126 | lineitem | 5 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 6 | delta | delta | ON
8196 | 248126 | lineitem | 7 | delta | delta | ON
8196 | 248126 | lineitem | 8 | lzo | zstd | ON
8196 | 248126 | lineitem | 9 | runlength | zstd | ON
8196 | 248126 | lineitem | 10 | delta | lzo | ON
8196 | 248126 | lineitem | 11 | delta | delta | ON
8196 | 248126 | lineitem | 12 | delta | delta | ON
8196 | 248126 | lineitem | 13 | bytedict | zstd | ON
8196 | 248126 | lineitem | 14 | bytedict | zstd | ON
8196 | 248126 | lineitem | 15 | text255 | zstd | ON
(16 rows)
```
# SYS\$1ANALYZE\$1HISTORY
记录 [ANALYZE](https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE.html) 操作的详细信息。
SYS\$1ANALYZE\$1HISTORY 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_ANALYZE_HISTORY.html)
## 示例查询
```
user_id | transaction_id | database_name | schema_name | table_name | table_id | is_automatic | Status | start_time | end_time | rows | modified_rows | analyze_threshold_percent | last_analyze_time
---------+----------------+---------------+-------------+---------------------+----------+--------------+--------+----------------------------+----------+-----------------+------+---------------+---------------------------+---------------------
101 | 8006 | dev | public | test_table_562bf8dc | 110427 | f | Full | 2023-09-21 18:33:08.504646 | 2023-09-21 18:33:24.296498 | 5 | 5 | 0 | 2000-01-01 00:00:00
```
# SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG
使用 SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG 跟踪动态数据掩蔽策略在引用受 RLS 保护关系的查询上的应用情况。
SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG 对以下用户可见：
+ 超级用户
+ 拥有 `sys:operator` 角色的用户
+ 拥有 ACCESS SYSTEM TABLE 权限的用户
常规用户将看到 0 行。
请注意，拥有 `sys:secadmin` 角色的用户看不到 SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG。
有关动态数据屏蔽的更多信息，请参阅[动态数据掩蔽](t_ddm.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_APPLIED_MASKING_POLICY_LOG.html)
## 示例查询
以下示例显示 `mask_credit_card_full` 屏蔽策略已附加到 `credit_db.public.credit_cards` 表中。
```
select policy_name, database_name, relation_name, schema_name, relation_kind
from sys_applied_masking_policy_log;
policy_name | database_name | relation_name | schema_name | relation_kind
----------------------+---------------+---------------+-------------+---------------
mask_credit_card_full | credit_db | credit_cards | public | table
(1 row)
```
# SYS\$1AUTOMATIC\$1OPTIMIZATION
使用 SYS\$1AUTOMATIC\$1OPTIMIZATION 可查看有关 Amazon Redshift 为自动优化（也称为自动处理）而运行的任务的详细信息。有关自动优化的更多信息，请参阅[自动数据库优化](c_autonomics.md)。
SYS\$1AUTOMATIC\$1OPTIMIZATION 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_AUTOMATIC_OPTIMIZATION.html)
## 使用说明
对于无服务器集群，compute\$1type 列将为空，因为我们没有区分主计算资源和主扩展计算资源。无服务器集群计算资源以 Redshift 处理器（RPU）用量为单位。有关更多信息，请参阅 [Amazon Redshift Serverless 的计算容量](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-capacity.html)。
## 示例
下面的查询显示对表 155259 执行的自动优化。
```
SELECT pid, trim(task_type) as task_type,
trim(database) as database,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE object_ids like '%155259%'
AND status = 'Task completed successfully';
task_type | database | status | event | event_time
------------+----------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
```
以下查询显示所有已执行的自动“VacuumSort”优化。有关“VacuumSort”的更多信息，请参阅[自动表排序](t_Reclaiming_storage_space202.md#automatic-table-sort)。
```
SELECT trim(task_type) as task_type,
trim(database) as database,
trim(object_type) as object_type,
trim(object_ids) as object_ids,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE task_type like '%VacuumSort%'
AND status = 'Task completed successfully';
task_type | database | object_type | object_ids | status | event | event_time
------------+----------------+-------------+------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | table | 155301 | Task completed successfully | Completed | 2025-12-22 07:14:00.065391
VacuumSort | tpcds_100g_oob | table | 155303 | Task completed successfully | Completed | 2025-12-22 07:14:09.158251
VacuumSort | tpcds_100g_oob | table | 155291 | Task completed successfully | Completed | 2025-12-22 07:17:06.61164
VacuumSort | tpcds_100g_oob | table | 155293 | Task completed successfully | Completed | 2025-12-22 07:17:37.015069
VacuumSort | tpcds_100g_oob | table | 155281 | Task completed successfully | Completed | 2025-12-22 07:18:54.903935
VacuumSort | tpcds_100g_oob | table | 155279 | Task completed successfully | Completed | 2025-12-22 07:20:13.960002
VacuumSort | tpcds_100g_oob | table | 155271 | Task completed successfully | Completed | 2025-12-22 07:21:26.095549
VacuumSort | tpcds_100g_oob | table | 155267 | Task completed successfully | Completed | 2025-12-22 07:22:48.119249
VacuumSort | tpcds_100g_oob | table | 155269 | Task completed successfully | Completed | 2025-12-22 07:24:12.010424
VacuumSort | tpcds_100g_oob | table | 155263 | Task completed successfully | Completed | 2025-12-22 07:25:35.958388
VacuumSort | tpcds_100g_oob | table | 155265 | Task completed successfully | Completed | 2025-12-22 07:26:40.580395
VacuumSort | tpcds_100g_oob | table | 155259 | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
(12 rows)
```
# SYS\$1AUTO\$1TABLE\$1OPTIMIZATION
记录 Amazon Redshift 对自动优化定义的表执行的自动操作。
SYS\$1AUTO\$1TABLE\$1OPTIMIZATION 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_AUTO_TABLE_OPTIMIZATION.html)
## 示例查询
在以下示例中，结果中的行显示了由 Amazon Redshift 执行的操作。
```
SELECT table_id, alter_table_type, status, event_time, alter_from
FROM SYS_AUTO_TABLE_OPTIMIZATION;
table_id | alter_table_type | status | event_time | alter_from
----------+---------------------+------------------------------------------------------+-----------------------------+-----------------
118082 | sortkey | Start | 2020-08-22 19:42:20.727049 |
118078 | sortkey | Start | 2020-08-22 19:43:54.728819 |
118082 | sortkey | Start | 2020-08-22 19:42:52.690264 |
118072 | sortkey | Start | 2020-08-22 19:44:14.793572 |
118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 |
118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | SORTKEY: None;
118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | SORTKEY: None;
118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | SORTKEY: None;
118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 |
118086 | sortkey | Start | 2020-08-22 19:42:00.685255 |
118082 | sortkey | Start | 2020-08-22 19:43:34.69531 |
118072 | sortkey | Start | 2020-08-22 19:44:46.703331 |
118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 |
118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 |
116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 |
110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 |
```
# SYS\$1CHILD\$1QUERY\$1TEXT
返回子查询的 SQL 文本。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_CHILD_QUERY_TEXT.html)
## 示例查询
在以下示例中，结果中的行显示了由 Amazon Redshift 执行的操作。
```
SELECT * from sys_child_query_text where query_id = '34487366' order by child_query_sequence asc, sequence asc;
user_id | query_id | child_query_sequence | sequence | text
--------|----------|----------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 34899339 | 1 | 0 | /* RQEV2-aY6ZZ1ZpQK */\nwith venue as (\n select venueid,\n venuename,\n venuestate\n from venue\n), event as (\n select eventid,\n venueid,\n date
100 | 34899339 | 1 | 1 | id,\n eventname\n from event\n where eventname like '3 Doors Down'\n), users as (\n select userid\n from users\n), sales as (\n select salesid,\n pricepaid,
100 | 34899339 | 1 | 2 | \n eventid,\n buyerid\n from sales\n)\nselect e.eventname,\n v.venuename,\n count(distinct(u.userid)) as unique_customers,\n sum(s.pricepaid) as total_sal
100 | 34899339 | 1 | 3 | es\nfrom venue as v inner join event e on v.venueid = e.venueid\ninner join sales s on e.eventid = s.eventid inner join users u on s.buyerid = u.userid\ngroup by 1,2\norder by 4 desc limit 100
```
# SYS\$1CONNECTION\$1LOG
记录身份验证尝试以及连接与断开连接。
SYS\$1CONNECTION\$1LOG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_CONNECTION_LOG.html)
## 示例查询
要查看打开连接的详细信息，请运行以下查询。
```
select record_time, user_name, database_name, remote_host, remote_port
from sys_connection_log
where event = 'initiating session'
and session_id not in
(select session_id from sys_connection_log
where event = 'disconnecting session')
order by 1 desc;
record_time | user_name | database_name | remote_host | remote_port
--------------------+-------------+-----------------+---------------+---------------------------------
2014-11-06 20:30:06 | rdsdb | dev | [local] |
2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111
2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333
2014-11-05 20:28:35 | rdsdb | dev | [local] |
(4 rows)
```
以下示例反映了一次失败的身份验证尝试和一次成功的连接与断开连接。
```
select event, record_time, remote_host, user_name
from sys_connection_log order by record_time;
event | record_time | remote_host | user_name
-----------------------+----------------------------+---------------+---------
authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john
authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john
initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john
disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john
(4 rows)
```
以下示例显示了 ODBC 驱动程序的版本、客户端计算机上的操作系统以及用于连接到 Amazon Redshift 集群的插件。在此示例中，使用的插件用于使用登录名和密码进行标准 ODBC 驱动程序身份验证。
```
select driver_version, os_version, plugin_name from sys_connection_log;
driver_version | os_version | plugin_name
----------------------------------------+-----------------------------------+--------------------
Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none
Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none
```
以下示例显示了客户端计算机上的操作系统版本、驱动程序版本和协议版本。
```
select os_version, driver_version, protocol_version from sys_connection_log;
os_version | driver_version | protocol_version
--------------------------------+------------------------------+--------------------
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
```
# SYS\$1COPY\$1JOB
使用 SYS\$1COPY\$1JOB 查看 COPY JOB 命令的详细信息。
此视图包含已创建的 COPY JOB 命令。
SYS\$1COPY\$1JOB 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_COPY_JOB.html)
# SYS\$1COPY\$1JOB\$1DETAIL
使用 SYS\$1COPY\$1JOB\$1DETAIL 查看 COPY JOB 命令的详细信息。
此视图包含已创建的 COPY JOB 命令。如果 COPY JOB 尝试加载文件但加载失败，则在将来的自动 COPY JOB 尝试时会跳过该文件。
SYS\$1COPY\$1JOB\$1DETAIL 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_COPY_JOB_DETAIL.html)
以下示例返回一行，其中包含摄取的条目。
```
SELECT * FROM SYS_COPY_JOB_DETAIL WHERE status ilike '%ingested%' limit 1;
user_id | 100
database_name | dev
job_name | many_job_4_3
job_id | 110702
file_location | saral-sqs-system4623202051-0
file_name | frenzy-9/4623202051/file_0_107
file_size | 11302
file_etag | 51b2d78ac5b5aecf4ee6f8374815ad19
modification_time | 2024-07-15 20:43:14
enqueue_time | 2024-07-15 20:44:24
status | Ingested
```
# SYS\$1COPY\$1JOB\$1INFO
使用 SYS\$1COPY\$1JOB\$1INFO 查看记录的有关 COPY JOB 的消息。
此视图包含有关已运行的 COPY JOB 中的错误的信息。
SYS\$1COPY\$1JOB\$1INFO 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_COPY_JOB_INFO.html)
# SYS\$1COPY\$1REPLACEMENTS
显示当无效的 UTF-8 字符由带有 ACCEPTINVCHARS 选项的 [COPY](r_COPY.md) 命令替换时所记录的日志。对于每个至少需要一次替换的节点切片上的前 100 行，将针对每行向 SYS\$1COPY\$1REPLACEMENTS 添加一个日志条目。
您可以使用此视图查看有关无服务器工作组和预置集群的信息。
SYS\$1COPY\$1REPLACEMENTS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_COPY_REPLACEMENTS.html)
## 示例查询
以下示例返回最近的 COPY 操作中的替换。
```
select query_idp, table_id, file_name, line_number, colname
from sys_copy_replacements
where query = pg_last_copy_id();
query_id | table_id | file_name | line_number | column_name
---------+----------+-------------------------------------------------------+-------------+--------
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 123 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 456 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 789 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 012 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 119 | city
...
```
# SYS\$1DATASHARE\$1CHANGE\$1LOG
记录用于跟踪创建器和使用者集群上的数据共享更改的综合视图。
SYS\$1DATASHARE\$1CHANGE\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_DATASHARE_CHANGE_LOG.html)
## 示例查询
以下示例显示了 SYS\$1DATASHARE\$1CHANGE\$1LOG 视图。
```
SELECT DISTINCT action
FROM sys_datashare_change_log
WHERE share_object_name LIKE 'tickit%';
action
-----------------------
"ALTER DATASHARE ADD"
```
# SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
使用 SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 视图，可以获取跨区域数据共享查询所导致的跨区域数据传输使用情况的摘要。SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 汇总了段级别的详细信息。
SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_DATASHARE_CROSS_REGION_USAGE.html)
## 示例查询
以下示例显示了 SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 视图。
```
SELECT query_id, segment_id, transferred_data, source_region
from sys_datashare_cross_region_usage
where query_id = pg_last_query_id()
order by query_id, segment_id;
query_id | segment_id | transferred_data | source_region
-----------+------------+------------------+---------------
200048 | 2 | 4194304 | us-west-1
200048 | 2 | 4194304 | us-east-2
```
# SYS\$1DATASHARE\$1USAGE\$1CONSUMER
记录数据共享的活动和使用情况。此视图仅与使用者集群相关。
SYS\$1DATASHARE\$1USAGE\$1CONSUMER 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_DATASHARE_USAGE_CONSUMER.html)
## 示例查询
以下示例显示了 SYS\$1DATASHARE\$1USAGE\$1CONSUMER 视图。
```
SELECT request_type, status, trim(error) AS error
FROM sys_datashare_usage_consumer
request_type | status | error_message
----------------+--------+---------------
"GET RELATION" | 0 |
```
# SYS\$1DATASHARE\$1USAGE\$1PRODUCER
记录数据共享的活动和使用情况。此视图仅与创建器集群有关。
SYS\$1DATASHARE\$1USAGE\$1PRODUCER 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_DATASHARE_USAGE_PRODUCER.html)
## 示例查询
以下示例显示了 SYS\$1DATASHARE\$1USAGE\$1PRODUCER 视图。
```
SELECT DISTINCT
FROM sys_datashare_usage_producer
WHERE object_name LIKE 'tickit%';
request_type
------------------
"GET RELATION"
```
# SYS\$1EXTERNAL\$1QUERY\$1DETAIL
使用 SYS\$1EXTERNAL\$1QUERY\$1DETAIL 查看段级别查询的详细信息。每行代表来自特定 WLM 查询的一段，其中包含 Amazon S3 中处理的行数、处理的字节数以及外部表的分区信息等详细信息。此视图除了具有与外部查询处理相关的更多详细信息之外，每一行还将在 SYS\$1QUERY\$1DETAIL 视图中有一个相应条目。
SYS\$1EXTERNAL\$1QUERY\$1DETAIL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_EXTERNAL_QUERY_DETAIL.html)
## 示例查询
以下查询显示了外部查询详细信息。
```
SELECT query_id,
segment_id,
start_time,
end_time,
total_partitions,
qualified_partitions,
scanned_files,
returned_rows,
returned_bytes,
trim(external_query_text) query_text,
trim(file_location) file_location
FROM sys_external_query_detail
ORDER BY query_id, start_time DESC
LIMIT 2;
```
示例输出。
```
query_id | segment_id | start_time | end_time | total_partitions | qualified_partitions | scanned_files | returned_rows | returned_bytes | query_text | file_location
----------+------------+----------------------------+----------------------------+------------------+----------------------+---------------+---------------+----------------+------------+---------------
763251 | 0 | 2022-02-15 22:32:23.312448 | 2022-02-15 22:32:24.036023 | 3 | 3 | 3 | 38203 | 2683414 | |
763254 | 0 | 2022-02-15 22:32:40.17103 | 2022-02-15 22:32:40.839313 | 3 | 3 | 3 | 38203 | 2683414 | |
```
# SYS\$1EXTERNAL\$1QUERY\$1ERROR
您可以查询 SYS\$1EXTERNAL\$1QUERY\$1ERROR 系统视图，以获取有关 Redshift Spectrum 扫描错误的信息。SYS\$1EXTERNAL\$1QUERY\$1ERROR 显示所记录的错误的示例。每个查询默认显示 10 个条目。
SYS\$1EXTERNAL\$1QUERY\$1ERROR 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_EXTERNAL_QUERY_ERROR.html)
## 示例查询
以下查询将返回所执行数据处理操作的行列表。
```
SELECT * FROM sys_external_query_error;
```
该查询返回的结果类似于以下内容。
```
user_id query_id file_location rowid column_name original_value modified_value trigger action action_value error_code
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
```
# SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION
使用 SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION 可查看 Amazon Redshift 使用额外的计算资源运行自动优化任务的使用期。有关自动优化的更多信息，请参阅[自动数据库优化](c_autonomics.md)。有关使用额外的计算资源运行的自动优化的更多信息，请参阅[分配额外的计算资源来执行自动数据库优化](t_extra-compute-autonomics.md)。
SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION 仅适用于预置集群。
SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.html)
## 示例
以下是一个查询示例，用于查找 2025 年 9 月 16 日执行的自动优化。
```
SELECT *
FROM sys_extra_compute_for_automatic_optimization
WHERE start_time BETWEEN '2025-09-16 00:00:00' AND '2025-09-16 23:59:59';
start_time | end_time | query_count | compute_seconds
---------------------+---------------------+-------------+-----------------
2025-09-16 00:00:00 | 2025-09-16 00:00:59 | 1 | 59
2025-09-16 00:01:05 | 2025-09-16 00:01:58 | 2 | 53
```
# SYS\$1INTEGRATION\$1ACTIVITY
SYS\$1INTEGRATION\$1ACTIVITY 显示有关已完成集成运行的详细信息。
SYS\$1INTEGRATION\$1ACTIVITY 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关零 ETL 集成的信息，请参阅《Amazon Redshift 管理指南》中的[使用零 ETL 集成](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html)
## 示例查询
以下 SQL 命令显示集成日志。
```
select * from sys_integration_activity;
integration_id | target_database | source | checkpoint_name | checkpoint_type | checkpoint_bytes | last_commit_timestamp | modified_tables | integration_start_time | integration_end_time
--------------------------------------+-----------------+--------+---------------------------------------------+------------------+------------------+-------------------------+-----------------+----------------------------+----------------------------
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_241_3_510.json | cdc | 762 | 2023-05-10 23:00:14.201 | 1 | 2023-05-10 23:00:45.054265 | 2023-05-10 23:00:46.339826
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_16329_3_17839.json | cdc | 13488 | 2023-05-11 01:33:57.411 | 2 | 2023-05-11 02:19:09.440121 | 2023-05-11 02:19:16.090492
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_5103_3_5532.json | cdc | 1657 | 2023-05-10 23:13:14.205 | 2 | 2023-05-10 23:13:23.545487 | 2023-05-10 23:13:25.652144
```
# SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY
SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY 显示零 ETL 集成的插入、删除和更新活动的详细信息。对于每次完成的摄取都会添加一行。
超级用户可以查看此表中的所有行。
有关更多信息，请参阅[零 ETL 集成](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_ACTIVITY.html)
## 示例查询
以下 SQL 命令显示集成的活动。
```
select * from sys_integration_table_activity;
integration_id | checkpoint_name | target_database | schema_name | table_name | table_id | record_time | transaction_id | inserted_rows | deleted_rows | updated_rows | bytes_ingested
--------------------------------------+-----------------+-----------------+-------------+-------------------+--------------+----------------------------+-----------------+----------------+--------------+--------------+---------------
4798e675-8f9f-4686-b05f-92c538e19629 | | sample_test2 | sample | SampleTestChannel | 111276 | 2023-05-12 12:40:30.656625 | 7736 | 2 | 0 | 0 | 125
```
# SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE
SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE 显示有关集成的表状态更改日志的详细信息。
超级用户可以查看此表中的所有行。
有关更多信息，请参阅[使用零 ETL 集成](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html)
## 示例查询
以下 SQL 命令显示集成日志。
```
select * from sys_integration_table_state_change;
integration_id | database_name | schema_name | table_name | new_state | table_last_replicated_checkpoint | state_change_reason | record_time
--------------------------------------+---------------+-------------+------------+-----------+-------------------------------------+---------------------+----------------------------
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest79 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:50.087868
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest56 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:45.54005
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest50 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:20.362504
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest18 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:32.544084
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest40t3s | sbtest23 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 15:49:05.186209
```
# SYS\$1LOAD\$1DETAIL
返回用于跟踪或排查数据加载的信息。
此视图记录了在每个数据文件加载到数据库表中时的进度。
此视图对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_LOAD_DETAIL.html)
## 示例查询
以下示例返回上次 COPY 操作的详细信息。
```
select query_id, trim(file_name) as file, record_time
from sys_load_detail
where query_id = pg_last_copy_id();
query_id | file | record_time
----------+----------------------------------+----------------------------
28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486
(1 row)
```
以下查询包含 TICKIT 数据库中初次加载表时的条目：
```
select query_id, trim(file_name), record_time
from sys_load_detail
where file_name like '%tickit%' order by query_id;
query_id | btrim | record_time
----------+--------------------------+----------------------------
22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186
22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604
22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472
22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305
22485 | tickit/allevents_pipe.txt| 2013-02-08 20:58:29.99489
22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939
22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491
22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055
22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049
22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502
22603 | tickit/allevents_pipe.txt| 2013-02-08 21:04:14.785124
22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594
(12 rows)
```
向此系统视图的日志文件写入一个记录的事实并不表示加载操作已作为其所属的事务的一部分成功提交。要验证加载提交，请查询 STL\$1UTILITYTEXT 视图并查找与 COPY 事务对应的 COMMIT 记录。例如，此查询基于针对 STL\$1UTILITYTEXT 的子查询联接 SYS\$1LOAD\$1DETAIL 和 STL\$1QUERY：
```
select l.query_id,rtrim(l.file_name),q.transaction_id
from sys_load_detail l, sys_query_text q
where l.query_id=q.query_id
and exists
(select xid from stl_utilitytext where xid=q.transaction_id and rtrim("text")='COMMIT');
query_id | rtrim | transaction_id
----------+---------------------------+-----------------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
# SYS\$1LUDF\$1DETAIL
SYS\$1LUDF\$1DETAIL 记录在特定查询中使用的 Lambda 用户定义函数（LUDF）的信息和指标。
SYS\$1LUDF\$1DETAIL 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_LUDF_DETAIL.html)
## 示例查询
以下示例在查询中使用 Lambda UDF，然后演示如何查询 SYS\$1LUDF\$1DETAIL 视图以查看函数执行详细信息。
```
SET SESSION AUTHORIZATION regular_user;
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT) RETURNS INT STABLE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
-- Switch to super user in order to inspect records in the LUDF SYS view.
SET SESSION AUTHORIZATION super_user;
select * from sys_ludf_detail;
```
示例输出：
```
user_id | transaction_id | query_id | function_oid | function_position | stream_id | segment_id | step_id | lambda_function_name | start_time | end_time | total_duration | invocations | total_rows | input_bytes | output_bytes
---------+----------------+----------+--------------+-------------------+-----------+------------+---------+----------------------+----------------------------+----------------------------+----------------+-------------+------------+-------------+--------------
100 | 1463 | 1544 | 111055 | 0 | 0 | 0 | 2 | lambda_sum | 2026-01-06 17:23:25.165898 | 2026-01-06 17:23:25.165898 | 414 | 1 | 2 | 277 | 18
(1 row)
```
# SYS\$1LOAD\$1ERROR\$1DETAIL
使用 SYS\$1LOAD\$1ERROR\$1DETAIL 查看 COPY 命令错误的详细信息。每行代表一个 COPY 命令。它包含正在运行和已完成的 COPY 命令。
SYS\$1LOAD\$1ERROR\$1DETAIL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_LOAD_ERROR_DETAIL.html)
## 示例查询
以下查询显示了特定查询的复制命令的加载错误详情。
```
SELECT query_id,
table_id,
start_time,
trim(file_name) AS file_name,
trim(column_name) AS column_name,
trim(column_type) AS column_type,
trim(error_message) AS error_message
FROM sys_load_error_detail
WHERE query_id = 762949
ORDER BY start_time
LIMIT 10;
```
示例输出。
```
query_id | table_id | start_time | file_name | column_name | column_type | error_message
----------+----------+----------------------------+------------------------------------------+-------------+-------------+------------------------------------------------
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_000 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_001 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
```
# SYS\$1LOAD\$1HISTORY
使用 SYS\$1LOAD\$1HISTORY 查看 COPY 命令的详细信息。每行代表一个 COPY 命令，其中包含某些字段的累积统计数据。它包含正在运行和已完成的 COPY 命令。
SYS\$1LOAD\$1HISTORY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_LOAD_HISTORY.html)
## 示例查询
以下查询显示了特定复制命令的加载行、字节、表和数据源。
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
WHERE query_id IN (6389,490791,441663,74374,72297)
ORDER BY query_id,
data_source DESC;
```
示例输出。
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------+-----------------------------------------------------------------------+-------------+---------------
6389 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196240296158
72297 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
74374 | ship_mode | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/ship_mode/ | 20 | 1320
441663 | income_band | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/income_band/ | 20 | 2152
490791 | customer_address | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/customer_address/ | 6000000 | 722924305
```
以下查询显示了复制命令的加载行、字节、表和数据源。
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
ORDER BY query_id DESC
LIMIT 10;
```
示例输出。
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------------+-----------------------------------------------------------------------------+-------------+-----------------
491058 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
490947 | web_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_sales/ | 720000376 | 22971988122819
490923 | web_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_returns/ | 71997522 | 96597496325
490918 | web_page | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_page/ | 3000 | 1320
490907 | warehouse | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/warehouse/ | 20 | 1320
490902 | time_dim | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/time_dim/ | 86400 | 1320
490876 | store_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_sales/ | 2879987999 | 151666241887933
490870 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196405607941
490865 | store | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store/ | 1002 | 365507
```
以下查询显示了复制命令的每日加载行和字节。
```
SELECT date_trunc('day',start_time) AS exec_day,
SUM(loaded_rows) AS loaded_rows,
SUM(loaded_bytes) AS loaded_bytes
FROM sys_load_history
GROUP BY exec_day
ORDER BY exec_day DESC;
```
示例输出。
```
exec_day | loaded_rows | loaded_bytes
---------------------+-------------+------------------
2022-01-20 00:00:00 | 6347386005 | 258329473070606
2022-01-19 00:00:00 | 19042158015 | 775198502204572
2022-01-18 00:00:00 | 38084316030 | 1550294469446883
2022-01-17 00:00:00 | 25389544020 | 1033271084791724
2022-01-16 00:00:00 | 19042158015 | 775222736252792
2022-01-15 00:00:00 | 19834245387 | 798122849155598
2022-01-14 00:00:00 | 75376544688 | 3077040926571384
```
# SYS\$1MV\$1REFRESH\$1HISTORY
结果包括有关所有实体化视图的刷新历史记录的信息。结果包括刷新类型（例如手动或自动）以及最近刷新的状态。
SYS\$1MV\$1REFRESH\$1HISTORY 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_MV_REFRESH_HISTORY.html)
## 示例查询
以下查询显示了实体化视图的刷新历史记录。
```
SELECT user_id,
session_id,
transaction_id,
database_name,
schema_name,
mv_id,
mv_name,
refresh_type,
status,
start_time,
end_time,
duration,
consumer_account,
consumer_region,
consumer_namespace
from sys_mv_refresh_history;
```
查询返回以下示例输出：
```
user_id | session_id | transaction_id | database_name | schema_name | mv_id | mv_name | refresh_type | status | start_time | end_time | duration | consumer_account | consumer_region | consumer_namespace
---------+------------+----------------+---------------+----------------------------+--------+--------------------+----------------+------------------------------------------------------------------------------------------------------+----------------------------+----------------------------+-----------+------------------+-----------------+------------------------------------
1 | 1073815659 | 15066 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | MV was already updated | 2023-10-26 15:59:20.952179 | 2023-10-26 15:59:20.952866 | 687 | | |
1 | 1073815659 | 15068 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | MV was already updated | 2023-10-26 15:59:21.008049 | 2023-10-26 15:59:21.008658 | 609 | | |
1 | 1073815659 | 15070 | ext_db | producer_schema | 203779 | producer_mv | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:21.064252 | 2023-10-26 15:59:21.064885 | 633 | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af
1 | 1073815659 | 15074 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:29.693329 | 2023-10-26 15:59:43.482842 | 13789513 | | |
1 | 1073815659 | 15076 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | Refresh successfully recomputed MV from scratch | 2023-10-26 15:59:43.550184 | 2023-10-26 15:59:47.880833 | 4330649 | | |
1 | 1073815659 | 15078 | dev | test_stl_mv_refresh_schema | 203779 | mv_refresh_error | Manual | Refresh failed due to an internal error | 2023-10-26 15:59:47.949052 | 2023-10-26 15:59:52.494681 | 4545629 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh failed because materialized view test_stl_mv_refresh_schema.child was not refreshed. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh skipped because materialized view test_stl_mv_refresh_schema.child was not refreshed.| 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
(10 rows)
```
# SYS\$1MV\$1STATE
结果包括有关所有实体化视图的状态的信息。这包括基表信息、架构属性和有关最近事件（例如删除列）的信息。
SYS\$1MV\$1STATE 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_MV_STATE.html)
## 示例查询
以下查询显示了实体化视图状态。
```
select * from sys_mv_state;
```
查询返回以下示例输出：
```
user_id | transaction_id | database_name | event_desc | start_time | base_table_database_name | base_table_schema | base_table_name | mv_schema | mv_name | state
---------+----------------+---------------+-----------------------------+----------------------------+--------------------------+-------------------+---------------------+-------------+----------------------------+--------------
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788268 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Recompute
106 | 12724 | tickit_db | ALTER TABLE ALTER DISTSTYLE | 2023-07-26 14:59:51.409014 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.822928 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051244 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857755 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051358 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788159 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857799 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788327 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Recompute
106 | 12727 | tickit_db | ALTER TABLE ALTER SORTKEY | 2023-07-26 15:00:08.006235 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.82297 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051321 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
```
# SYS\$1PROCEDURE\$1CALL
使用 SYS\$1PROCEDURE\$1CALL 视图以获取有关存储过程调用的信息，包括开始时间、结束时间、存储过程调用的状态以及嵌套存储过程调用的调用层次结构。每个存储过程调用接受一个查询 ID。
SYS\$1PROCEDURE\$1CALL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_PROCEDURE_CALL.html)
## 示例查询
以下查询返回嵌套存储过程调用的层次结构。
```
select query_id, datediff(seconds, start_time, end_time) as elapsed_time, status, trim(query_text) as call, caller_procedure_query_id from sys_procedure_call;
```
示例输出。
```
query_id | elapsed_time | status | call | caller_procedure_query_id
----------+--------------+---------+--------------------------------------------------+---------------------------
3087 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d(1) | 3085
3085 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d_2(1); |
(2 rows)
```
# SYS\$1PROCEDURE\$1MESSAGES
SYS\$1PROCEDURE\$1MESSAGES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_PROCEDURE_MESSAGES.html)
## 示例查询
以下查询显示了 SYS\$1PROCEDURE\$1MESSAGES 的示例输出。
```
select transaction_id, query_id, record_time, log_level, trim(message), line_number from sys_procedure_messages;
```
```
transaction_id | query_id | record_time | log_level | btrim | line_number
---------------+----------+----------------------------+-----------+---------------------------+-------------
25267 | 80562 | 2023-07-17 14:38:31.910136 | NOTICE | test_notice_msg_b9f1e749 | 8
25267 | 80562 | 2023-07-17 14:38:31.910002 | LOG | test_log_msg_833c7420 | 6
25267 | 80562 | 2023-07-17 14:38:31.910111 | INFO | test_info_msg_651373d9 | 7
25267 | 80562 | 2023-07-17 14:38:31.910154 | WARNING | test_warning_msg_831c5747 | 9
(4 rows)
```
# SYS\$1QUERY\$1DETAIL
使用 SYS\$1QUERY\$1DETAIL 查看不同指标级别的查询的详细信息，每行表示有关给定指标级别的特定 WLM 查询的详细信息。此视图包含许多类型的查询，例如 DDL、DML 和实用程序命令（例如：复制和卸载）。根据查询类型，某些列可能不相关。例如，external\$1scanned\$1bytes 与内部表无关。
SYS\$1QUERY\$1DETAIL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
要验证包含已执行查询的事务是否成功提交，您需要在系统表和 `sys_transaction_history` 表之间执行联接操作。例如：
```
SELECT
th.transaction_id,
qd.query_id,
th.status AS transaction_status
FROM
sys_query_detail qd
LEFT JOIN sys_query_history qh ON qd.query_id = qh.query_id
LEFT JOIN sys_transaction_history th on qh.transaction_id = th.transaction_id;
```
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## 使用说明
SYS\$1QUERY\$1DETAIL 可以包含步骤、流、段和子查询级别的指标。除了引用 metrics\$1level 列外，还可以根据下表，通过引用 step\$1id、segment\$1id 和 stream\$1id 字段来查看给定行显示的指标级别。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## 示例查询
以下示例返回了 SYS\$1QUERY\$1DETAIL 的输出。
以下查询显示了步骤级别的查询元数据详细信息，包括步骤名称、input\$1bytes、output\$1bytes、input\$1rows、output\$1rows。
```
SELECT query_id,
child_query_sequence,
stream_id,
segment_id,
step_id,
trim(step_name) AS step_name,
duration,
input_bytes,
output_bytes,
input_rows,
output_rows
FROM sys_query_detail
WHERE query_id IN (193929)
ORDER BY query_id,
stream_id,
segment_id,
step_id DESC;
```
示例输出。
```
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | duration | input_bytes | output_bytes | input_rows | output_rows
----------+----------------------+-----------+------------+---------+------------+-----------------+-------------+--------------+------------+-------------
193929 | 2 | 0 | 0 | 3 | hash | 37144 | 0 | 9350272 | 0 | 292196
193929 | 5 | 0 | 0 | 3 | hash | 9492 | 0 | 23360 | 0 | 1460
193929 | 1 | 0 | 0 | 3 | hash | 46809 | 0 | 9350272 | 0 | 292196
193929 | 4 | 0 | 0 | 2 | return | 7685 | 0 | 896 | 0 | 112
193929 | 1 | 0 | 0 | 2 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 2 | 0 | 0 | 2 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 2 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 2 | return | 11033 | 0 | 14336 | 0 | 112
193929 | 2 | 0 | 0 | 1 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 1 | 0 | 0 | 1 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 1 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 1 | aggregate | 11033 | 0 | 201488 | 0 | 14
193929 | 4 | 0 | 0 | 1 | aggregate | 7685 | 0 | 28784 | 0 | 14
193929 | 5 | 0 | 0 | 0 | scan | 9492 | 0 | 23360 | 292196 | 1460
193929 | 4 | 0 | 0 | 0 | scan | 7685 | 0 | 1344 | 112 | 112
193929 | 2 | 0 | 0 | 0 | scan | 37144 | 0 | 7304900 | 292196 | 292196
193929 | 3 | 0 | 0 | 0 | scan | 11033 | 0 | 13440 | 112 | 112
193929 | 1 | 0 | 0 | 0 | scan | 46809 | 0 | 7304900 | 292196 | 292196
193929 | 5 | 0 | 0 | -1 | | 9492 | 12288 | 0 | 0 | 0
193929 | 1 | 0 | 0 | -1 | | 46809 | 16384 | 0 | 0 | 0
193929 | 2 | 0 | 0 | -1 | | 37144 | 16384 | 0 | 0 | 0
193929 | 4 | 0 | 0 | -1 | | 7685 | 28672 | 0 | 0 | 0
193929 | 3 | 0 | 0 | -1 | | 11033 | 114688 | 0 | 0 | 0
```
要按从最常用到最不常用的顺序查看数据库中的表，请使用以下示例。将 *sample\$1data\$1dev* 替换为您自己的数据库。请注意，此查询将计算从创建集群时开始的查询数量，但当您的数据仓库空间不足时，不会保存系统视图数据。
```
SELECT table_name, COUNT (DISTINCT query_id)
FROM SYS_QUERY_DETAIL
WHERE table_name LIKE 'sample_data_dev%'
GROUP BY table_name
ORDER BY COUNT(*) DESC;
+---------------------------------+-------+
| table_name | count |
+---------------------------------+-------+
| sample_data_dev.tickit.venue | 4 |
| sample_data_dev.myunload1.venue | 3 |
| sample_data_dev.tickit.listing | 1 |
| sample_data_dev.tickit.category | 1 |
| sample_data_dev.tickit.users | 1 |
| sample_data_dev.tickit.date | 1 |
| sample_data_dev.tickit.sales | 1 |
| sample_data_dev.tickit.event | 1 |
+---------------------------------+-------+
```
以下示例显示了单个 WLM 查询的不同指标级别。
```
SELECT query_id, child_query_sequence, stream_id, segment_id, step_id, step_name, start_time, end_time, metrics_level
FROM sys_query_detail
WHERE query_id = 1553 AND step_id = -1
ORDER BY stream_id, segment_id, step_id;
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | start_time | end_time | metrics_level
----------+----------------------+-----------+------------+---------+-----------+----------------------------+----------------------------+---------------
1553 | 1 | -1 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.847838 | child query
1553 | 1 | 0 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.835609 | stream
1553 | 1 | 0 | 0 | -1 | | 2024-10-17 02:28:49.824677 | 2024-10-17 02:28:49.830372 | segment
1553 | 1 | 1 | -1 | -1 | | 2024-10-17 02:28:49.835624 | 2024-10-17 02:28:49.845773 | stream
1553 | 1 | 1 | 1 | -1 | | 2024-10-17 02:28:49.84088 | 2024-10-17 02:28:49.842388 | segment
1553 | 1 | 1 | 2 | -1 | | 2024-10-17 02:28:49.835926 | 2024-10-17 02:28:49.844396 | segment
1553 | 1 | 2 | -1 | -1 | | 2024-10-17 02:28:49.846949 | 2024-10-17 02:28:49.847838 | stream
1553 | 1 | 2 | 3 | -1 | | 2024-10-17 02:28:49.847013 | 2024-10-17 02:28:49.847485 | segment
(8 rows)
```
# SYS\$1QUERY\$1EXPLAIN
显示已提交供执行的查询的 EXPLAIN 计划。
SYS\$1QUERY\$1EXPLAIN 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_QUERY_EXPLAIN.html)
## 示例查询
以下示例是单个查询的 EXPLAIN 计划。
```
SELECT * FROM sys_query_explain WHERE query_id = 612635 ORDER BY plan_node_id;
userid | query_id | child_query_sequence | plan_node_id | plan_parent_id | plan_node | plan_info
--------+----------+----------------------+--------------+----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 612635 | 1 | 1 | 0 | XN Limit (cost=3604047533041.00..3604047533041.25 rows=100 width=20) |
100 | 612635 | 1 | 2 | 1 | -> XN Merge (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Merge Key: sum(b.totalprice)
100 | 612635 | 1 | 3 | 2 | -> XN Network (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Send to leader
100 | 612635 | 1 | 4 | 3 | -> XN Sort (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Sort Key: sum(b.totalprice)
100 | 612635 | 1 | 5 | 4 | -> XN HashAggregate (cost=2604047529640.76..2604047529747.78 rows=42809 width=20) |
100 | 612635 | 1 | 6 | 5 | -> XN Hash Join DS_DIST_NONE (cost=15104956.16..2602364653507.34 rows=336575226684 width=20) | Hash Cond: (("outer".listid = "inner".listid) AND ("outer".sellerid = "inner".sellerid))
100 | 612635 | 1 | 7 | 6 | -> XN Seq Scan on listing b (cost=0.00..7884677.12 rows=788467712 width=24) |
100 | 612635 | 1 | 8 | 6 | -> XN Hash (cost=7063797.76..7063797.76 rows=706379776 width=8) |
100 | 612635 | 1 | 9 | 8 | -> XN Seq Scan on sales a (cost=0.00..7063797.76 rows=706379776 width=8) |
(9 rows)
```
# SYS\$1QUERY\$1HISTORY
使用 SYS\$1QUERY\$1HISTORY 查看用户查询的详细信息。每行代表一个用户查询，其中包含某些字段的累积统计数据。此视图包含许多类型的查询，例如数据定义语言 (DDL)、数据操作语言 (DML)、复制、卸载和 Amazon Redshift Spectrum。它包含正在运行和已完成的查询。
SYS\$1QUERY\$1HISTORY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
要验证包含已执行查询的事务是否成功提交，您需要在系统表和 `sys_transaction_history` 表之间执行联接操作。例如：
```
SELECT
qh.transaction_id,
qh.query_id,
qh.status AS query_status,
qh.query_type,
TRIM(qh.query_text) AS query_text,
th.status AS transaction_status
FROM
sys_query_history qh
LEFT JOIN
sys_transaction_history th ON qh.transaction_id = th.transaction_id;
```
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_QUERY_HISTORY.html)
## 示例查询
以下查询返回了正在运行的查询和已排队的查询。
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time
FROM sys_query_history
WHERE status IN ('running','queued')
ORDER BY start_time;
```
示例输出。
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time
---------+----------+----------------+------------+---------+---------------+---------------------------+----------------------------+------------------+--------------+------------+----------------
101 | 760705 | 852337 | 1073832321 | running | tpcds_1t | 2022-02-15 19:03:19.67849 | 2022-02-15 19:03:19.739811 | f | 61321 | 0 | 0
```
以下查询返回了特定查询的查询开始时间、结束时间、排队时间、已用时间、计划时间和其他元数据。
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time,
planning_time,
trim(query_text) as query_text
FROM sys_query_history
WHERE query_id = 3093;
```
示例输出。
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time | planning_time | query_text
--------+----------+----------------+------------+------------+---------------+----------------------------+----------------------------+------------------+--------------+------------+----------------+---------------+-------------------------------------
106 | 3093 | 11759 | 1073750146 | success | dev | 2023-03-16 16:53:17.840214 | 2023-03-16 16:53:18.106588 | f | 266374 | 0 | 105725 | 136589 | select count(*) from item;
```
以下示例列出了 10 个最近的 SELECT 查询。
```
SELECT query_id,
transaction_id,
session_id,
start_time,
elapsed_time,
queue_time,
execution_time,
returned_rows,
returned_bytes
FROM sys_query_history
WHERE query_type = 'SELECT'
ORDER BY start_time DESC limit 10;
```
示例输出。
```
query_id | transaction_id | session_id | start_time | elapsed_time | queue_time | execution_time | returned_rows | returned_bytes
----------+----------------+------------+----------------------------+--------------+------------+----------------+---------------+----------------
526532 | 61093 | 1073840313 | 2022-02-09 04:43:24.149603 | 520571 | 0 | 481293 | 1 | 3794
526520 | 60850 | 1073840313 | 2022-02-09 04:38:27.24875 | 635957 | 0 | 596601 | 1 | 3679
526508 | 60803 | 1073840313 | 2022-02-09 04:37:51.118835 | 563882 | 0 | 503135 | 5 | 17216
526505 | 60763 | 1073840313 | 2022-02-09 04:36:48.636224 | 649337 | 0 | 589823 | 1 | 652
526478 | 60730 | 1073840313 | 2022-02-09 04:36:11.741471 | 14611321 | 0 | 14544058 | 0 | 0
526467 | 60636 | 1073840313 | 2022-02-09 04:34:11.91463 | 16711367 | 0 | 16633767 | 1 | 575
511617 | 617946 | 1074009948 | 2022-01-20 06:21:54.44481 | 9937090 | 0 | 9899271 | 100 | 12500
511603 | 617941 | 1074259415 | 2022-01-20 06:21:45.71744 | 8065081 | 0 | 7582500 | 100 | 8889
511595 | 617935 | 1074128320 | 2022-01-20 06:21:44.030876 | 1051270 | 0 | 1014879 | 1 | 72
511584 | 617931 | 1074030019 | 2022-01-20 06:21:42.764088 | 609033 | 0 | 485887 | 100 | 8438
```
以下查询显示了每日 Select 查询的计数和平均查询用时。
```
SELECT date_trunc('day',start_time) AS exec_day,
status,
COUNT(*) AS query_cnt,
AVG(datediff (microsecond,start_time,end_time)) AS elapsed_avg
FROM sys_query_history
WHERE query_type = 'SELECT'
AND start_time >= '2022-01-14'
AND start_time <= '2022-01-18'
GROUP BY exec_day,
status
ORDER BY exec_day,
status;
```
示例输出。
```
exec_day | status | query_cnt | elapsed_avg
---------------------+---------+-----------+------------
2022-01-14 00:00:00 | success | 5253 | 56608048
2022-01-15 00:00:00 | success | 7004 | 56995017
2022-01-16 00:00:00 | success | 5253 | 57016363
2022-01-17 00:00:00 | success | 5309 | 55236784
2022-01-18 00:00:00 | success | 8092 | 54355124
```
以下查询显示了每日查询所用时间性能。
```
SELECT distinct date_trunc('day',start_time) AS exec_day,
query_count.cnt AS query_count,
Percentile_cont(0.5) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P50_runtime,
Percentile_cont(0.8) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P80_runtime,
Percentile_cont(0.9) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P90_runtime,
Percentile_cont(0.99) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P99_runtime,
Percentile_cont(1.0) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS max_runtime
FROM sys_query_history
LEFT JOIN (SELECT date_trunc('day',start_time) AS day, count(*) cnt
FROM sys_query_history
WHERE query_type = 'SELECT'
GROUP by 1) query_count
ON date_trunc('day',start_time) = query_count.day
WHERE query_type = 'SELECT'
ORDER BY exec_day;
```
示例输出。
```
exec_day | query_count | p50_runtime | p80_runtime | p90_runtime | p99_runtime | max_runtime
---------------------+-------------+-------------+-------------+-------------+--------------+--------------
2022-01-14 00:00:00 | 5253 | 16816922.0 | 69525096.0 | 158524917.8 | 486322477.52 | 1582078873.0
2022-01-15 00:00:00 | 7004 | 15896130.5 | 71058707.0 | 164314568.9 | 500331542.07 | 1696344792.0
2022-01-16 00:00:00 | 5253 | 15750451.0 | 72037082.2 | 159513733.4 | 480372059.24 | 1594793766.0
2022-01-17 00:00:00 | 5309 | 15394513.0 | 68881393.2 | 160254700.0 | 493372245.84 | 1521758640.0
2022-01-18 00:00:00 | 8092 | 15575286.5 | 68485955.4 | 154559572.5 | 463552685.39 | 1542783444.0
2022-01-19 00:00:00 | 5860 | 16648747.0 | 72470482.6 | 166485138.2 | 492038228.67 | 1693483241.0
2022-01-20 00:00:00 | 1751 | 15422072.0 | 69686381.0 | 162315385.0 | 497066615.00 | 1439319739.0
2022-02-09 00:00:00 | 13 | 6382812.0 | 17616161.6 | 21197988.4 | 23021343.84 | 23168439.0
```
以下查询显示了查询类型分布。
```
SELECT query_type,
COUNT(*) AS query_count
FROM sys_query_history
GROUP BY query_type
ORDER BY query_count DESC;
```
示例输出。
```
query_type | query_count
------------+-------------
UTILITY | 134486
SELECT | 38537
DDL | 4832
OTHER | 768
LOAD | 768
CTAS | 748
COMMAND | 92
```
下面的示例显示了多个查询之间的查询哈希结果差异。观察以下查询：
```
CREATE TABLE test_table (col1 INT);
INSERT INTO test_table VALUES (1),(2);
SELECT * FROM test_table;
SELECT * FROM test_table;
SELECT col1 FROM test_table;
SELECT * FROM test_table WHERE col1=1;
SELECT * FROM test_table WHERE col1=2;
SELECT query_id, TRIM(user_query_hash) AS user_query_hash, TRIM(generic_query_hash) AS generic_query_hash, TRIM(query_text) AS text FROM sys_query_history ORDER BY start_time
DESC LIMIT 10;
```
以下是输出示例：
```
query_id | user_query_hash | generic_query_hash | text
---------+-----------------+--------------------+----------
24723049 | oPuFtjEPLTs= | oPuFtjEPLTs= | select query_id, trim(user_query_hash) as user_query_hash, trim(generic_query_hash) as generic_query_hash, query_hash_version, trim(query_text) as text from sys_query_history order by start_time\r\ndesc limit 20
24723045 | Gw2Kwdd8m2I= | IwfRu8/XAKI= | select * from test_table where col1=2 limit 100
24723041 | LNw2vx0GDXo= | IwfRu8/XAKI= | select * from test_table where col1=1 limit 100
24723036 | H+qep/c82Y8= | H+qep/c82Y8= | select col1 from test_table limit 100
24723033 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723029 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723023 | 50sirx9E1hU= | uO36Z1a/QYs= | insert into test_table values (1),(2)
24723021 | YSVnlivZHeo= | YSVnlivZHeo= | create table test_table (col1 int)
```
`SELECT * FROM test_table;` 和 `SELECT col1 FROM test_table;` 具有相同的 user\$1query\$1hash 值，因为 test\$1table 只有一列。`SELECT * FROM test_table WHERE col1=1;` 和 `SELECT * FROM test_table WHERE col1=2;` 具有不同的 user\$1query\$1hash 值，但具有相同的 generic\$1query\$1hash 值，因为这两个查询在查询字面值 1 和 2 之外是相同的。
# SYS\$1QUERY\$1TEXT
使用 SYS\$1QUERY\$1TEXT 查看所有查询的查询文本。每行代表最多 4000 个字符的查询的查询文本（从序列号 0 开始）。当查询语句包含超过 4000 个字符时，通过增加每行的序列号来为该语句记录额外的行。此视图记录所有用户查询文本，例如 DDL、实用程序、Amazon Redshift 查询和仅限领导节点的查询。
SYS\$1QUERY\$1TEXT 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_QUERY_TEXT.html)
## 示例查询
以下查询返回了正在运行的查询和已排队的查询。
```
SELECT user_id,
query_id,
transaction_id,
session_id, start_time,
sequence, trim(text) as text from sys_query_text
ORDER BY sequence;
```
示例输出。
```
user_id | query_id | transaction_id | session_id | start_time | sequence | text
--------+----------+-----------------+------------+----------------------------+----------+----------------------------------------------------------------------------------------------------------------------
100 | 4 | 1396 | 1073750220 | 2023-04-28 16:44:55.887184 | 0 | SELECT trim(text) as text, sequence FROM sys_query_text WHERE query_id = pg_last_query_id() AND user_id > 1 AND start
_time > '2023-04-28 16:44:55.922705+00:00'::timestamp order by sequence;
```
以下查询返回已在数据库的组中授予或撤消的权限。
```
SELECT
SPLIT_PART(text, ' ', 1) as grantrevoke,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'GROUP'))), ' ', 2) as group,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), ' '))), 'ON', 1) as type,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 2) || ' ' || SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 3) as entity
FROM SYS_QUERY_TEXT
WHERE (text LIKE 'GRANT%' OR text LIKE 'REVOKE%') AND text LIKE '%GROUP%';
+-------------+----------+--------+----------+
| grantrevoke | group | type | entity |
+-------------+----------+--------+----------+
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | USAGE | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
+-------------+----------+--------+----------+
```
# SYS\$1REDSHIFT\$1TEMPLATE
使用 SYS\$1REDSHIFT\$1TEMPLATE 查看 Redshift TEMPLATES 的详细信息。
此视图包含已创建的 TEMPLATES。
SYS\$1REDSHIFT\$1TEMPLATE 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_REDSHIFT_TEMPLATE.html)
## 示例查询
以下查询返回当前用户可见的所有模板：
```
SELECT * FROM SYS_REDSHIFT_TEMPLATE;
```
示例输出。
```
database_name | schema_name | template_name | template_type | create_time | last_modified_time | owner_id | last_modified_by | template_parameters
---------------+-------------+--------------------+---------------+----------------------------+----------------------------+----------+------------------+---------------------
dev | s1 | shapefile_template | 1 | 2025-12-17 22:42:02.079758 | 2025-12-17 22:42:02.079758 | 101 | 101 | {
"SIMPLIFY_AUTO": 0.000001,
"SHAPEFILE": 1,
"COMPRESSION_UPDATE": 0
}
dev | s2 | orc_template | 1 | 2025-12-17 22:42:23.582815 | 2025-12-17 22:42:23.582815 | 101 | 101 | {
"ORC": "serializetojson_default"
}
dev | s1 | csv_template | 1 | 2025-12-17 22:43:01.822361 | 2025-12-17 22:43:01.822361 | 101 | 101 | {
"ENCRYPTED": 1,
"CSV": 1,
"ENCODING": 1,
"DELIMITER": ","
}
(3 rows)
```
# SYS\$1RESTORE\$1LOG
在经典大小调整期间，使用 SYS\$1RESTORE\$1LOG 监控集群中每个表迁入 RA3 节点的进度。它捕获调整大小操作期间数据迁移的历史吞吐量。有关经典调整 RA3 节点大小的更多信息，请参阅[经典调整大小](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
SYS\$1RESTORE\$1LOG 仅对超级用户可见。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_RESTORE_LOG.html)
## 示例查询
以下查询使用 SYS\$1RESTORE\$1LOG 计算数据处理的吞吐量。
```
SELECT
ROUND(sum(delta_data_processed) / 1024.0, 2) as data_processed_gb,
ROUND(datediff(sec, min(event_time), max(event_time)) / 3600.0, 2) as duration_hr,
ROUND(data_processed_gb/duration_hr, 2) as throughput_gb_per_hr
from sys_restore_log;
```
示例输出。
```
data_processed_gb | duration_hr | throughput_gb_per_hr
-------------------+-------------+----------------------
0.91 | 8.37 | 0.11
(1 row)
```
以下查询显示所有再分配类型。
```
SELECT * from sys_restore_log ORDER BY event_time;
```
```
database_name | schema_name | table_name | table_id | action | total_data_processed | delta_data_processed | event_time | table_size | message | redistribution_type
---------------+----------------------+----------------------+----------+-----------------------------+----------------------+----------------------+----------------------------+------------+---------+--------------------------
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution started | 0 | | 2024-01-05 02:18:00.744977 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution started | 0 | | 2024-01-05 02:18:02.756675 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution completed | 90 | 90 | 2024-01-05 02:23:30.643718 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution completed | 325 | 325 | 2024-01-05 02:23:45.998249 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution started | 0 | | 2024-01-05 02:23:46.083849 | 30 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution started | 0 | | 2024-01-05 02:23:46.855728 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution completed | 45 | 45 | 2024-01-05 02:24:16.343029 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution completed | 30 | 30 | 2024-01-05 02:24:20.584703 | 30 | | Rebalance Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution started | 0 | | 2024-01-05 04:54:55.641741 | 190 | | Restore Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution checkpointed | 29.4342113157737 | 29.4342113157737 | 2024-01-05 04:55:04.770696 | 190 | | Restore Disteven Table
(8 rows)
```
# SYS\$1RESTORE\$1STATE
在经典大小调整期间，使用 SYS\$1RESTORE\$1STATE 监控每个表的迁移进度。当目标节点类型为 RA3 时，这特别适用。有关经典调整 RA3 节点大小的更多信息，请参阅[经典调整大小](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
SYS\$1RESTORE\$1STATE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_RESTORE_STATE.html)
## 示例查询
以下查询返回正在运行的查询和已排队的查询的记录。
```
SELECT * FROM sys_restore_state;
```
示例输出。
```
userid | database_name | schema_id | table_id | table_name | redistribution_status | precentage_redistributed | redistribution_type
--------+---------------+-----------+----------+----------------+-----------------------+--------------------------+-------------------------
1 | test1 | 124865 | 124878 | customer_key_4 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124874 | customer_key_3 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124870 | customer_key_2 | Completed | 100 | Rebalance Disteven Table
1 | dev | 124865 | 124866 | customer_key_1 | In progress | 13.52 | Restore Distkey Table
```
以下是数据处理状态。
```
SELECT
redistribution_status, ROUND(SUM(block_count) / 1024.0, 2) AS total_size_gb
FROM sys_restore_state sys inner join stv_tbl_perm stv
on sys.table_id = stv.id
GROUP BY sys.redistribution_status;
```
示例输出。
```
redistribution_status | total_size_gb
-----------------------+---------------
Completed | 0.07
Pending | 0.71
In progress | 0.20
(3 rows)
```
# SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
记录超出架构限额时的匹配项、事务 ID 和其他有用信息。此系统表是 [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md) 的转换。
r\$1SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_SCHEMA_QUOTA_VIOLATIONS.html)
## 示例查询
以下查询显示违反限额的结果：
```
SELECT user_id, TRIM(schema_name) "schema_name", quota, disk_usage, record_time FROM
sys_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC;
```
此查询返回指定 schema 的以下示例输出：
```
user_id| schema_name | quota | disk_usage | record_time
-------+--------------+-------+------------+----------------------------
104 | sales_schema | 2048 | 2798 | 2020-04-20 20:09:25.494723
(1 row)
```
# SYS\$1SERVERLESS\$1USAGE
使用 SYS\$1SERVERLESS\$1USAGE 查看资源的 Amazon Redshift Serverless 使用情况的详细信息。此系统视图不适用于预置 Amazon Redshift 集群。
此视图包含无服务器使用情况摘要，包括用于处理查询的计算容量数量以及以 1 分钟粒度使用的 Amazon Redshift 托管式存储量。计算容量以 Redshift 处理单元 (RPU) 为单位衡量，并按每秒计量以 RPU 秒为单位运行的工作负载。RPU 用于处理对数据仓库中加载数据的查询、从 Amazon S3 数据湖查询或使用联合查询从操作数据库访问。Amazon Redshift Serverless 可在 SYS\$1SERVERLESS\$1USAGE 中将信息保留 7 天时间。
有关计算成本计费的示例，请参阅 [Amazon Redshift Serverless 的计费](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html)。
SYS\$1SERVERLESS\$1USAGE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_SERVERLESS_USAGE.html)
## 使用说明
+ 在某些情况下，compute\$1seconds 为 0，但 charged\$1seconds 大于 0，反之亦然。这是由于在系统视图中记录数据的方式而导致的正常行为。为了更准确地表示无服务器使用情况的详细信息，我们建议聚合数据。
## 示例
要通过查询 charged\$1seconds 获取一段时间间隔内使用的 RPU 小时数的总费用，请运行以下查询：
```
select trunc(start_time) "Day",
(sum(charged_seconds)/3600::double precision) * as cost_incurred
from sys_serverless_usage
group by 1
order by 1
```
请注意，在此时间间隔内可能会有空闲时间。空闲时间不会增加使用的 RPU。
# SYS\$1SESSION\$1HISTORY
使用 SYS\$1SESSION\$1HISTORY 查看有关当前活动的会话和会话历史记录的信息。
SYS\$1SESSION\$1HISTORY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_SESSION_HISTORY.html)
### 示例
以下是 SYS\$1SESSION\$1HISTORY 的示例输出。
```
select * from sys_session_history;
user_id | session_id | database_name | status | session_timeout | start_time | end_time
---------+------------+------------------+--------+-----------------+----------------------------+----------------------------
1 | 1073971370 | dev | closed | 0 | 2023-07-17 15:50:12.030104 | 2023-07-17 15:50:12.123218
1 | 1073979694 | dev | closed | 0 | 2023-07-17 15:50:24.117947 | 2023-07-17 15:50:24.131859
1 | 1073873049 | dev | closed | 0 | 2023-07-17 15:49:29.067398 | 2023-07-17 15:49:29.070294
1 | 1073873086 | database18127a4a | closed | 0 | 2023-07-17 15:49:29.119018 | 2023-07-17 15:49:29.125925
1 | 1073832112 | dev | closed | 0 | 2023-07-17 15:49:29.164688 | 2023-07-17 15:49:29.179631
1 | 1073987697 | dev | closed | 0 | 2023-07-17 15:49:29.26749 | 2023-07-17 15:49:29.273034
1 | 1073922429 | dev | closed | 0 | 2023-07-17 15:49:33.35315 | 2023-07-17 15:49:33.367499
1 | 1073766783 | dev | closed | 0 | 2023-07-17 15:49:45.38237 | 2023-07-17 15:49:45.396902
1 | 1073807506 | dev | active | 0 | 2023-07-17 15:51:48 |
```
# SYS\$1SPATIAL\$1SIMPLIFY
您可以查询系统视图 SYS\$1SPATIAL\$1SIMPLIFY，以使用 COPY 命令获取有关简化空间几何对象的信息。在 shapefile 上使用 COPY 时，您可以指定 SIMPLIFY `tolerance`、SIMPLIFY AUTO 和 SIMPLIFY AUTO `max_tolerance` 摄入选项。简化的结果在 SYS\$1SPATIAL\$1SIMPLIFY 系统视图中进行总结。
当设置 SIMPLIFY AUTO `max_tolerance` 时，此视图为每个超出最大大小的几何体都包含一行。当设置 SIMPLIFY `tolerance` 时，则存储整个 COPY 操作的一行。此行引用 COPY 查询 ID 和指定的简化容差。
有关加载 shapefile 的更多信息，请参阅[将 shapefile 加载到 Amazon Redshift](spatial-copy-shapefile.md)。
SYS\$1SPATIAL\$1SIMPLIFY 对所有用户均可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_SPATIAL_SIMPLIFY.html)
## 示例查询
以下查询返回 COPY 简化的记录的列表。
```
SELECT * FROM sys_spatial_simplify;
query_id | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
----------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
# SYS\$1STREAM\$1SCAN\$1ERRORS
记录通过串流摄取加载的记录的错误。
SYS\$1STREAM\$1SCAN\$1ERRORS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html)
# SYS\$1STREAM\$1SCAN\$1STATES
记录通过串流摄取加载的记录的扫描状态。
SYS\$1STREAM\$1SCAN\$1STATES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SYS_STREAM_SCAN_STATES.html)
以下查询显示了特定查询的串流和主题数据。
```
select query_id,mv_name::varchar,external_schema_name::varchar,stream_name::varchar,sum(scanned_rows) total_records,
sum(scanned_bytes) total_bytes from sys_stream_scan_states where query in (5401180,8601939) group by 1,2,3,4;
query_id | mv_name | external_schema_name | stream_name | total_records | total_bytes
------------+----------------+----------------------+-----------------+---------------+----------------
5401180 | kinesistest | kinesis | kinesisstream | 1493255696 | 3209006490704
8601939 | msktest | msk | mskstream | 14677023 | 31056580668
(2 rows)
```
# SYS\$1TRANSACTION\$1HISTORY
跟踪查询时，使用 SYS\$1TRANSACTION\$1HISTORY 查看事务的详细信息。
SYS\$1TRANSACTION\$1HISTORY 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_TRANSACTION_HISTORY.html)
## 示例查询
```
select * from sys_transaction_history order by transaction_start_time desc;
user_id | transaction_id | isolation_level | status | transaction_start_time | commit_start_time | commit_end_time | blocks_committed | undo_transaction_id
---------+----------------+-----------------+------------+----------------------------+----------------------------+----------------------------+------------------+---------------------
100 | 1310 | Serializable | committed | 2023-08-27 21:03:11.822205 | 2023-08-28 21:03:11.825287 | 2023-08-28 21:03:11.854883 | 17 | -1
101 | 1345 | Serializable | committed | 2023-08-27 21:03:12.000278 | 2023-08-28 21:03:12.003736 | 2023-08-28 21:03:12.030061 | 17 | -1
102 | 1367 | Serializable | committed | 2023-08-27 21:03:12.1532 | 2023-08-28 21:03:12.156124 | 2023-08-28 21:03:12.186468 | 17 | -1
100 | 1370 | Serializable | committed | 2023-08-27 21:03:12.199316 | 2023-08-28 21:03:12.204854 | 2023-08-28 21:03:12.238186 | 24 | -1
100 | 1408 | Serializable | committed | 2023-08-27 21:03:53.891107 | 2023-08-28 21:03:53.894825 | 2023-08-28 21:03:53.927465 | 17 | -1
100 | 1409 | Serializable | rolledback | 2023-08-27 21:03:53.936431 | 2000-01-01 00:00:00 | 2023-08-28 21:04:08.712532 | 0 | 1409
101 | 1415 | Serializable | committed | 2023-08-27 21:04:24.283188 | 2023-08-28 21:04:24.289196 | 2023-08-28 21:04:24.374318 | 25 | -1
101 | 1416 | Serializable | committed | 2023-08-27 21:04:24.38818 | 2023-08-28 21:04:24.391688 | 2023-08-28 21:04:24.415135 | 17 | -1
100 | 1417 | Serializable | rolledback | 2023-08-27 21:04:24.424252 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.354826 | 0 | 1417
101 | 1418 | Serializable | rolledback | 2023-08-27 21:04:24.425195 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.680355 | 0 | 1418
100 | 1420 | Serializable | committed | 2023-08-27 21:04:28.697607 | 2023-08-28 21:04:28.702374 | 2023-08-28 21:04:28.735541 | 23 | -1
101 | 1421 | Serializable | committed | 2023-08-27 21:04:28.744854 | 2023-08-28 21:04:28.749344 | 2023-08-28 21:04:28.779029 | 23 | -1
101 | 1423 | Serializable | committed | 2023-08-27 21:04:28.78942 | 2023-08-28 21:04:28.791556 | 2023-08-28 21:04:28.817485 | 16 | -1
100 | 1430 | Serializable | committed | 2023-08-27 21:04:28.917788 | 2023-08-28 21:04:28.919993 | 2023-08-28 21:04:28.944812 | 16 | -1
102 | 1494 | Serializable | committed | 2023-08-27 21:04:37.029058 | 2023-08-28 21:04:37.033137 | 2023-08-28 21:04:37.062001 | 16 | -1
```
# SYS\$1UDF\$1LOG
记录在执行用户定义的函数 (UDF) 期间生成的系统定义的错误和警告消息。
SYS\$1UDF\$1LOG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_UDF_LOG.html)
## 示例查询
以下示例说明 UDF 如何处理系统定义的错误。第一个块显示了返回参数的逆参数的 UDF 函数的定义。在运行函数并提供 0 作为参数时，函数返回错误。最后一条语句返回在 SYS\$1UDF\$1LOG 中记录的错误消息。
```
-- Create a function to find the inverse of a number.
CREATE OR REPLACE FUNCTION f_udf_inv(a int)
RETURNS float
IMMUTABLE AS $$return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to create an error.
Select f_udf_inv(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------
2211 | 2023-08-23 15:53:11.360538 | ZeroDivisionError: integer division or modulo by zero line 2, in f_udf_inv\n return 1/a\n
```
以下示例将日志记录和警告消息添加到 UDF 中，以便被零除运算生成警告消息而不是停止并显示错误消息。
```
-- Create a function to find the inverse of a number and log a warning if you input 0.
CREATE OR REPLACE FUNCTION f_udf_inv_log(a int)
RETURNS float IMMUTABLE
AS $$
import logging
logger = logging.getLogger() #get root logger
if a==0:
logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n')
return 0
else:
return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to trigger the warning.
Select f_udf_inv_log(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------------------------------
0 | 2023-08-23 16:10:48.833503 | WARNING: You attempted to divide by zero.\nReturning zero instead of error.\n
```
# SYS\$1UNLOAD\$1DETAIL
使用 SYS\$1UNLOAD\$1DETAIL 查看 UNLOAD 操作的详细信息。这会为由 UNLOAD 语句创建的每个文件记录一行。例如，如果 UNLOAD 创建 12 个文件，则 SYS\$1UNLOAD\$1DETAIL 将包含 12 个对应的行。
SYS\$1UNLOAD\$1DETAIL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_UNLOAD_DETAIL.html)
## 示例查询
以下查询显示了卸载查询详细信息，包括卸载命令的格式、行和文件计数。
```
select query_id, substring(file_name, 0, 50), transfer_size, file_format from sys_unload_detail;
```
示例输出。
```
query_id | substring | transfer_size | file_format
----------+-------------------------------------------------------------+---------------+-------------
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0000_part_00.gz | 395886 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0001_part_00.gz | 406444 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0002_part_00.gz | 409431 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0003_part_00.gz | 403051 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0004_part_00.gz | 413592 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0005_part_00.gz | 395689 | Text
(6 rows)
```
# SYS\$1UNLOAD\$1HISTORY
使用 SYS\$1UNLOAD\$1HISTORY 查看 UNLOAD 命令的详细信息。每行代表一个 UNLOAD 命令，其中包含某些字段的累积统计数据。它包含正在运行和已完成的 UNLOAD 命令。
SYS\$1UNLOAD\$1HORITY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_UNLOAD_HISTORY.html)
## 示例查询
以下查询显示了卸载查询详细信息，包括卸载命令的格式、行和文件计数。
```
SELECT query_id,
file_format,
start_time,
duration,
unloaded_rows,
unloaded_files_count
FROM sys_unload_history
ORDER BY query_id,
file_format limit 100;
```
示例输出。
```
query_id | file_format | start_time | duration | unloaded_rows | unloaded_files_count
----------+-------------+----------------------------+----------+---------------+----------------------
527067 | Text | 2022-02-09 05:18:35.844452 | 5932478 | 10 | 1
```
# SYS\$1USERLOG
记录数据库用户的以下更改的详细信息。
+ 创建用户
+ 删除用户
+ 更改用户（重命名）
+ 更改用户（更改属性）
您可以查询此视图，以查看有关无服务器工作组和预置集群的信息。
SYS\$1USERLOG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_USERLOG.html)
## 示例查询
以下示例执行四个用户操作，然后查询 SYS\$1USERLOG 视图。
```
CREATE USER userlog1 password 'Userlog1';
ALTER USER userlog1 createdb createuser;
ALTER USER userlog1 rename to userlog2;
DROP user userlog2;
SELECT user_id, user_name, original_user_name, action, has_create_db_privs, is_superuser from SYS_USERLOG order by record_time desc;
```
```
user_id | user_name | original_user_name | action | has_create_db_privs | is_superuser
--------+------------+--------------------+---------+---------------------+------------
108 | userlog2 | | drop | 1 | 1
108 | userlog2 | userlog1 | rename | 1 | 1
108 | userlog1 | | alter | 1 | 1
108 | userlog1 | | create | 0 | 0
(4 rows)
```
# SYS\$1VACUUM\$1HISTORY
使用 SYS\$1VACUUM\$1HISTORY 查看 vacuum 查询的详细信息。有关 VACUUM 命令的信息，请参阅[VACUUM](r_VACUUM_command.md)。
SYS\$1VACUUM\$1HISTORY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/SYS_VACUUM_HISTORY.html)
# 用于迁移到 SYS 监控视图的系统视图映射
当您将 Amazon Redshift 预调配集群迁移到 Amazon Redshift Serverless 时，您的监控或诊断查询可能会引用仅在预调配集群上可用的系统视图。您可以更新查询以使用 SYS 监控视图。本页提供了仅预调配视图到 SYS 视图的映射，供您在更新查询时参考。
**Topics**
+ [SYS\$1QUERY\$1HISTORY](#sys_view_migration-SYS_QUERY_HISTORY)
+ [SYS\$1QUERY\$1DETAIL](#sys_view_migration-SYS_QUERY_DETAIL)
+ [SYS\$1RESTORE\$1LOG](#sys_view_migration-SYS_RESTORE_LOG)
+ [SYS\$1RESTORE\$1STATE](#sys_view_migration-SYS_RESTORE_STATE)
+ [SYS\$1TRANSACTION\$1HISTORY](#sys_view_migration-SYS_TRANSACTION_HISTORY)
+ [SYS\$1QUERY\$1TEXT](#sys_view_migration-SYS_QUERY_TEXT)
+ [SYS\$1CONNECTION\$1LOG](#sys_view_migration-SYS_CONNECTION_LOG)
+ [SYS\$1SESSION\$1HISTORY](#sys_view_migration-SYS_SESSION_HISTORY)
+ [SYS\$1LOAD\$1DETAIL](#sys_view_migration-SYS_LOAD_DETAIL)
+ [SYS\$1LOAD\$1HISTORY](#sys_view_migration-SYS_LOAD_HISTORY)
+ [SYS\$1LOAD\$1ERROR\$1DETAIL](#sys_view_migration-SYS_LOAD_ERROR_DETAIL)
+ [SYS\$1UNLOAD\$1HISTORY](#sys_view_migration-SYS_UNLOAD_HISTORY)
+ [SYS\$1UNLOAD\$1DETAIL](#sys_view_migration-SYS_UNLOAD_DETAIL)
+ [SYS\$1COPY\$1REPLACEMENTS](#sys_view_migration-SYS_COPY_REPLACEMENTS)
+ [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](#sys_view_migration-SYS_DATASHARE_USAGE_CONSUMER)
+ [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](#sys_view_migration-SYS_DATASHARE_USAGE_PRODUCER)
+ [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](#sys_view_migration-SYS_DATASHARE_CROSS_REGION_USAGE)
+ [SYS\$1DATASHARE\$1CHANGE\$1LOG](#sys_view_migration-SYS_DATASHARE_CHANGE_LOG)
+ [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](#sys_view_migration-SYS_EXTERNAL_QUERY_DETAIL)
+ [SYS\$1EXTERNAL\$1QUERY\$1ERROR](#sys_view_migration-SYS_EXTERNAL_QUERY_ERROR)
+ [SYS\$1VACUUM\$1HISTORY](#sys_view_migration-SYS_VACUUM_HISTORY)
+ [SYS\$1ANALYZE\$1HISTORY](#sys_view_migration-SYS_ANALYZE_HISTORY)
+ [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](#sys_view_migration-SYS_ANALYZE_COMPRESSION_HISTORY)
+ [SYS\$1MV\$1REFRESH\$1HISTORY](#sys_view_migration-SYS_MV_REFRESH_HISTORY)
+ [SYS\$1MV\$1STATE](#sys_view_migration-SYS_MV_STATE)
+ [SYS\$1PROCEDURE\$1CALL](#sys_view_migration-SYS_PROCEDURE_CALL)
+ [SYS\$1PROCEDURE\$1MESSAGES](#sys_view_migration-SYS_PROCEDURE_MESSAGES)
+ [SYS\$1UDF\$1LOG](#sys_view_migration-SYS_UDF_LOG)
+ [SYS\$1USERLOG](#sys_view_migration-SYS_USERLOG)
+ [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](#sys_view_migration-SYS_SCHEMA_QUOTA_VIOLATIONS)
+ [SYS\$1SPATIAL\$1SIMPLIFY](#sys_view_migration-SYS_SPATIAL_SIMPLIFY)
## SYS\$1QUERY\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中定义。
+ [STL\$1DDLTEXT](r_STL_DDLTEXT.md)
+ [STL\$1ERROR](r_STL_ERROR.md)
+ [STL\$1QUERY](r_STL_QUERY.md)
+ [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md)
+ [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md)
+ [STV\$1INFLIGHT](r_STV_INFLIGHT.md)
+ [STV\$1RECENTS](r_STV_RECENTS.md)
+ [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md)
+ [SVL\$1COMPILE](r_SVL_COMPILE.md)
+ [SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS](r_SVL_MULTI_STATEMENT_VIOLATIONS.md)
+ [SVL\$1QLOG](r_SVL_QLOG.md)
+ [SVL\$1QUERY\$1QUEUE\$1INFO](r_SVL_QUERY_QUEUE_INFO.md)
+ [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)
+ [SVL\$1TERMINATE](r_SVL_TERMINATE.md)
## SYS\$1QUERY\$1DETAIL
以下各表中的部分或全部列也在 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中定义。
+ [STL\$1AGGR](r_STL_AGGR.md)
+ [STL\$1ALERT\$1EVENT\$1LOG](r_STL_ALERT_EVENT_LOG.md)
+ [STL\$1BCAST](r_STL_BCAST.md)
+ [STL\$1DELETE](r_STL_DELETE.md)
+ [STL\$1DIST](r_STL_DIST.md)
+ [STL\$1EXPLAIN](r_STL_EXPLAIN.md)
+ [STL\$1HASH](r_STL_HASH.md)
+ [STL\$1HASHJOIN](r_STL_HASHJOIN.md)
+ [STL\$1INSERT](r_STL_INSERT.md)
+ [STL\$1LIMIT](r_STL_LIMIT.md)
+ [STL\$1MERGE](r_STL_MERGE.md)
+ [STL\$1MERGEJOIN](r_STL_MERGEJOIN.md)
+ [STL\$1NESTLOOP](r_STL_NESTLOOP.md)
+ [STL\$1PARSE](r_STL_PARSE.md)
+ [STL\$1PLAN\$1INFO](r_STL_PLAN_INFO.md)
+ [STL\$1PROJECT](r_STL_PROJECT.md)
+ [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md)
+ [STL\$1RETURN](r_STL_RETURN.md)
+ [STL\$1SAVE](r_STL_SAVE.md)
+ [STL\$1SCAN](r_STL_SCAN.md)
+ [STL\$1SORT](r_STL_SORT.md)
+ [STL\$1STREAM\$1SEGS](r_STL_STREAM_SEGS.md)
+ [STL\$1UNIQUE](r_STL_UNIQUE.md)
+ [STL\$1WINDOW](r_STL_WINDOW.md)
+ [STV\$1EXEC\$1STATE](r_STV_EXEC_STATE.md)
+ [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md)
+ [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md)
+ [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md)
+ [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md)
+ [SVL\$1QUERY\$1REPORT](r_SVL_QUERY_REPORT.md)
+ [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md)
+ [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md)
## SYS\$1RESTORE\$1LOG
下表中的部分或全部列也在 [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md) 中定义。
+ [SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS](r_SVL_RESTORE_ALTER_TABLE_PROGRESS.md)
## SYS\$1RESTORE\$1STATE
下表中的部分或全部列也在 [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md) 中定义。
+ [STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE](r_STV_XRESTORE_ALTER_QUEUE_STATE.md)
## SYS\$1TRANSACTION\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md) 中定义。
+ [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md)
+ [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md)
+ [STL\$1UNDONE](r_STL_UNDONE.md)
## SYS\$1QUERY\$1TEXT
下表中的部分或全部列也在 [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md) 中定义。
+ [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)
## SYS\$1CONNECTION\$1LOG
下表中的部分或全部列也在 [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md) 中定义。
+ [STL\$1CONNECTION\$1LOG](r_STL_CONNECTION_LOG.md)
## SYS\$1SESSION\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md) 中定义。
+ [STL\$1SESSIONS](r_STL_SESSIONS.md)
+ [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md)
+ [STV\$1SESSIONS](r_STV_SESSIONS.md)
## SYS\$1LOAD\$1DETAIL
下表中的部分或全部列也在 [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md) 中定义。
+ [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)
## SYS\$1LOAD\$1HISTORY
下表中的部分或全部列也在 [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md) 中定义。
+ [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)
## SYS\$1LOAD\$1ERROR\$1DETAIL
以下各表中的部分或全部列也在 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md) 中定义。
+ [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md)
+ [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)
## SYS\$1UNLOAD\$1HISTORY
下表中的部分或全部列也在 [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md) 中定义。
+ [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md)
## SYS\$1UNLOAD\$1DETAIL
下表中的部分或全部列也在 [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md) 中定义。
+ [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md)
## SYS\$1COPY\$1REPLACEMENTS
下表中的部分或全部列也在 [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md) 中定义。
+ [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md)
## SYS\$1DATASHARE\$1USAGE\$1CONSUMER
下表中的部分或全部列也在 [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md) 中定义。
+ [SVL\$1DATASHARE\$1USAGE\$1CONSUMER](r_SVL_DATASHARE_USAGE_CONSUMER.md)
## SYS\$1DATASHARE\$1USAGE\$1PRODUCER
下表中的部分或全部列也在 [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md) 中定义。
+ [SVL\$1DATASHARE\$1USAGE\$1PRODUCER](r_SVL_DATASHARE_USAGE_PRODUCER.md)
## SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
下表中的部分或全部列也在 [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md) 中定义。
+ [SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SVL_DATASHARE_CROSS_REGION_USAGE.md)
## SYS\$1DATASHARE\$1CHANGE\$1LOG
下表中的部分或全部列也在 [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md) 中定义。
+ [SVL\$1DATASHARE\$1CHANGE\$1LOG](r_SVL_DATASHARE_CHANGE_LOG.md)
## SYS\$1EXTERNAL\$1QUERY\$1DETAIL
以下各表中的部分或全部列也在 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md) 中定义。
+ [SVL\$1FEDERATED\$1QUERY](r_SVL_FEDERATED_QUERY.md)
+ [SVL\$1S3LIST](r_SVL_S3LIST.md)
+ [SVL\$1S3QUERY](r_SVL_S3QUERY.md)
+ [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md)
## SYS\$1EXTERNAL\$1QUERY\$1ERROR
以下各表中的部分或全部列也在 [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md) 中定义。
+ [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md)
## SYS\$1VACUUM\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中定义。
+ [STL\$1VACUUM](r_STL_VACUUM.md)
+ [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)
+ [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md)
+ [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md)
## SYS\$1ANALYZE\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md) 中定义。
+ [STL\$1ANALYZE](r_STL_ANALYZE.md)
## SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md) 中定义。
+ [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md)
## SYS\$1MV\$1REFRESH\$1HISTORY
以下各表中的部分或全部列也在 [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md) 中定义。
+ [SVL\$1MV\$1REFRESH\$1STATUS](r_SVL_MV_REFRESH_STATUS.md)
## SYS\$1MV\$1STATE
以下各表中的部分或全部列也在 [SYS\$1MV\$1STATE](SYS_MV_STATE.md) 中定义。
+ [STL\$1MV\$1STATE](r_STL_MV_STATE.md)
## SYS\$1PROCEDURE\$1CALL
以下各表中的部分或全部列也在 [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md) 中定义。
+ [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md)
## SYS\$1PROCEDURE\$1MESSAGES
以下各表中的部分或全部列也在 [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md) 中定义。
+ [SVL\$1STORED\$1PROC\$1MESSAGES](r_SVL_STORED_PROC_MESSAGES.md)
## SYS\$1UDF\$1LOG
以下各表中的部分或全部列也在 [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md) 中定义。
+ [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md)
## SYS\$1USERLOG
以下各表中的部分或全部列也在 [SYS\$1USERLOG](SYS_USERLOG.md) 中定义。
+ [STL\$1USERLOG](r_STL_USERLOG.md)
## SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
以下各表中的部分或全部列也在 [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md) 中定义。
+ [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md)
## SYS\$1SPATIAL\$1SIMPLIFY
以下各表中的部分或全部列也在 [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md) 中定义。
+ [SVL\$1SPATIAL\$1SIMPLIFY](r_SVL_SPATIAL_SIMPLIFY.md)
# 系统监控（仅已预置）
可以在已预置集群上查询以下系统表和视图。STL 和 STV 表和视图包含一些系统表中的数据的子集。它们提供对在这些表中找到的常用查询数据的更快速、更便捷的访问。
SVCS 视图提供了有关主集群和并发扩展集群上的查询的详细信息。SVL 视图仅提供在主集群上运行的查询的信息，但 SVL\$1STATEMENTTEXT 除外。SVL\$1STATEMENTTEXT 可以包含在并发扩展集群和主集群上运行的查询的信息。
**Topics**
+ [用于日志记录的 STL 视图](c_intro_STL_tables.md)
+ [快照数据的 STV 表](c_intro_STV_tables.md)
+ [主集群和并发扩展集群的 SVCS 视图](svcs_views.md)
+ [主集群的 SVL 视图](svl_views.md)
# 用于日志记录的 STL 视图
STL 系统视图从 Amazon Redshift 日志文件中生成，以提供该系统的历史记录。
这些文件位于数据仓库集群中的每个节点上。STL 视图提取日志中的信息并将信息的格式设置为可供系统管理员使用的视图。
**日志保留** – STL 系统视图保留七天的日志历史记录。所有集群大小和节点类型的日志保留均得到保证，并且不受集群工作负载变化的影响。日志保留也不会受到集群状态（例如集群暂停）的影响。仅当集群是新集群时，您的日志历史记录才会少于七天。您不必执行任何操作即可保留日志，但必须定期将日志数据复制到其他表，或将其上传到 Amazon S3，以保留超过 7 天的日志数据。
**Topics**
+ [STL\$1AGGR](r_STL_AGGR.md)
+ [STL\$1ALERT\$1EVENT\$1LOG](r_STL_ALERT_EVENT_LOG.md)
+ [STL\$1ANALYZE](r_STL_ANALYZE.md)
+ [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md)
+ [STL\$1BCAST](r_STL_BCAST.md)
+ [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md)
+ [STL\$1CONNECTION\$1LOG](r_STL_CONNECTION_LOG.md)
+ [STL\$1DDLTEXT](r_STL_DDLTEXT.md)
+ [STL\$1DELETE](r_STL_DELETE.md)
+ [STL\$1DISK\$1FULL\$1DIAG](r_STL_DISK_FULL_DIAG.md)
+ [STL\$1DIST](r_STL_DIST.md)
+ [STL\$1ERROR](r_STL_ERROR.md)
+ [STL\$1EXPLAIN](r_STL_EXPLAIN.md)
+ [STL\$1FILE\$1SCAN](r_STL_FILE_SCAN.md)
+ [STL\$1HASH](r_STL_HASH.md)
+ [STL\$1HASHJOIN](r_STL_HASHJOIN.md)
+ [STL\$1INSERT](r_STL_INSERT.md)
+ [STL\$1LIMIT](r_STL_LIMIT.md)
+ [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)
+ [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)
+ [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md)
+ [STL\$1MERGE](r_STL_MERGE.md)
+ [STL\$1MERGEJOIN](r_STL_MERGEJOIN.md)
+ [STL\$1MV\$1STATE](r_STL_MV_STATE.md)
+ [STL\$1NESTLOOP](r_STL_NESTLOOP.md)
+ [STL\$1PARSE](r_STL_PARSE.md)
+ [STL\$1PLAN\$1INFO](r_STL_PLAN_INFO.md)
+ [STL\$1PROJECT](r_STL_PROJECT.md)
+ [STL\$1QUERY](r_STL_QUERY.md)
+ [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md)
+ [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)
+ [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md)
+ [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md)
+ [STL\$1RETURN](r_STL_RETURN.md)
+ [STL\$1S3CLIENT](r_STL_S3CLIENT.md)
+ [STL\$1S3CLIENT\$1ERROR](r_STL_S3CLIENT_ERROR.md)
+ [STL\$1SAVE](r_STL_SAVE.md)
+ [STL\$1SCAN](r_STL_SCAN.md)
+ [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md)
+ [STL\$1SESSIONS](r_STL_SESSIONS.md)
+ [STL\$1SORT](r_STL_SORT.md)
+ [STL\$1SSHCLIENT\$1ERROR](r_STL_SSHCLIENT_ERROR.md)
+ [STL\$1STREAM\$1SEGS](r_STL_STREAM_SEGS.md)
+ [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md)
+ [STL\$1UNDONE](r_STL_UNDONE.md)
+ [STL\$1UNIQUE](r_STL_UNIQUE.md)
+ [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md)
+ [STL\$1USAGE\$1CONTROL](r_STL_USAGE_CONTROL.md)
+ [STL\$1USERLOG](r_STL_USERLOG.md)
+ [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md)
+ [STL\$1VACUUM](r_STL_VACUUM.md)
+ [STL\$1WINDOW](r_STL_WINDOW.md)
+ [STL\$1WLM\$1ERROR](r_STL_WLM_ERROR.md)
+ [STL\$1WLM\$1RULE\$1ACTION](r_STL_WLM_RULE_ACTION.md)
+ [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md)
# STL\$1AGGR
分析查询的聚合执行步骤。这些步骤发生于执行聚合函数和 GROUP BY 语句期间。
STL\$1AGGR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1AGGR 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_AGGR.html)
## 示例查询
返回有关 SLICE 1 和 TBL 239 的聚合执行步骤的信息。
```
select query, segment, bytes, slots, occupied, maxlength, is_diskbased, workmem, type
from stl_aggr where slice=1 and tbl=239
order by rows
limit 10;
```
```
query | segment | bytes | slots | occupied | maxlength | is_diskbased | workmem | type
-------+---------+-------+---------+----------+-----------+--------------+-----------+--------
562 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED
616 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED
546 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED
547 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN
685 | 1 | 32 | 4194304 | 1 | 0 | f | 383385600 | HASHED
652 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN
680 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN
658 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN
686 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN
695 | 1 | 32 | 4194304 | 1 | 0 | f | 383385600 | HASHED
(10 rows)
```
# STL\$1ALERT\$1EVENT\$1LOG
当查询优化程序发现可能指示性能问题的条件时记录警报。使用 STL\$1ALERT\$1EVENT\$1LOG 视图标识用于改进查询性能的机会。
一个查询包含多个区段，而且每个区段包含一个或多个步骤。有关更多信息，请参阅 [查询处理](c-query-processing.md)。
STL\$1ALERT\$1EVENT\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1ALERT\$1EVENT\$1LOG 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_ALERT_EVENT_LOG.html)
## 使用说明
您可以使用 STL\$1ALERT\$1EVENT\$1LOG 来标识查询中的潜在问题，然后按照[查询性能优化](c-optimizing-query-performance.md)中的做法来优化数据库设计并重新编写查询。STL\$1ALERT\$1EVENT\$1LOG 将记录以下警报：
+ **缺失统计数据**
统计数据缺失。在加载数据或进行大量更改之后运行 ANALYZE 并结合使用 STATUPDATE 和 COPY 操作。有关更多信息，请参阅 [设计查询的 Amazon Redshift 最佳实践](c_designing-queries-best-practices.md)。
+ **嵌套循环**
一个嵌套循环通常是一个笛卡尔积。评估您的查询以确保所有参与表均已高效地联接。
+ **选择性非常强的筛选条件**
返回的行与扫描的行的比率小于 0.05。扫描的行数是 `rows_pre_user_filter` 的值，而返回的行数是 [STL\$1SCAN](r_STL_SCAN.md) 系统视图中的行数值。表示查询正在扫描数量极其大的行来确定结果集。这可能是由于排序键缺失或不正确导致的。有关更多信息，请参阅 [排序键](t_Sorting_data.md)。
+ **过多的虚影行**
扫描跳过了相对大量的标记为已删除但未抽空的行或已插入但未提交的行。有关更多信息，请参阅 [对表执行 vacuum 操作](t_Reclaiming_storage_space202.md)。
+ **大型分配**
为进行哈希联接或聚合重新分配了超过 1000000 的行。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
+ **大型广播**
为进行哈希联接广播了超过了 1000000 的行。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
+ **顺序执行**
DS\$1DIST\$1ALL\$1INNER 重新分配方式已在查询计划中指明，此方式强制实施序列执行，因为整个内部表已重新分配到单个节点。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
## 示例查询
以下查询显示了四种查询的警报事件。
```
SELECT query, substring(event,0,25) as event,
substring(solution,0,25) as solution,
trim(event_time) as event_time from stl_alert_event_log order by query;
query | event | solution | event_time
-------+-------------------------------+------------------------------+---------------------
6567 | Missing query planner statist | Run the ANALYZE command | 2014-01-03 18:20:58
7450 | Scanned a large number of del | Run the VACUUM command to rec| 2014-01-03 21:19:31
8406 | Nested Loop Join in the query | Review the join predicates to| 2014-01-04 00:34:22
29512 | Very selective query filter:r | Review the choice of sort key| 2014-01-06 22:00:00
(4 rows)
```
# STL\$1ANALYZE
记录 [ANALYZE](r_ANALYZE.md) 操作的详细信息。
STL\$1ANALYZE 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_ANALYZE.html)
## 示例查询
以下示例联接 STV\$1TBL\$1PERM 以显示表名称和执行详细信息。
```
select distinct a.xid, trim(t.name) as name, a.status, a.rows, a.modified_rows, a.starttime, a.endtime
from stl_analyze a
join stv_tbl_perm t on t.id=a.table_id
where name = 'users'
order by starttime;
xid | name | status | rows | modified_rows | starttime | endtime
-------+-------+-----------------+-------+---------------+---------------------+--------------------
1582 | users | Full | 49990 | 49990 | 2016-09-22 22:02:23 | 2016-09-22 22:02:28
244287 | users | Full | 24992 | 74988 | 2016-10-04 22:50:58 | 2016-10-04 22:51:01
244712 | users | Full | 49984 | 24992 | 2016-10-04 22:56:07 | 2016-10-04 22:56:07
245071 | users | Skipped | 49984 | 0 | 2016-10-04 22:58:17 | 2016-10-04 22:58:17
245439 | users | Skipped | 49984 | 1982 | 2016-10-04 23:00:13 | 2016-10-04 23:00:13
(5 rows)
```
# STL\$1ANALYZE\$1COMPRESSION
记录在 COPY 或 ANALYZE COMPRESSION 命令期间压缩分析操作的详细信息。
STL\$1ANALYZE\$1COMPRESSION 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_ANALYZE_COMPRESSION.html)
## 示例查询
以下示例检查在同一个会话中运行的最后一个 COPY 命令对 `lineitem` 表执行压缩分析的详细信息。
```
select xid, tbl, btrim(tablename) as tablename, col, old_encoding, new_encoding, best_compression_encoding, mode
from stl_analyze_compression
where xid = (select xid from stl_query where query = pg_last_copy_id()) order by col;
xid | tbl | tablename | col | old_encoding | new_encoding | best_compression_encoding | mode
------+--------+-----------+-----+-----------------+-----------------+---------------------------+----------------
5308 | 158961 | $lineitem | 0 | mostly32 | az64 | delta | ON
5308 | 158961 | $lineitem | 1 | mostly32 | az64 | az64 | ON
5308 | 158961 | $lineitem | 2 | lzo | az64 | az64 | ON
5308 | 158961 | $lineitem | 3 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 4 | bytedict | az64 | bytedict | ON
5308 | 158961 | $lineitem | 5 | mostly32 | az64 | az64 | ON
5308 | 158961 | $lineitem | 6 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 7 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 8 | lzo | lzo | lzo | ON
5308 | 158961 | $lineitem | 9 | runlength | runlength | runlength | ON
5308 | 158961 | $lineitem | 10 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 11 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 12 | delta | az64 | az64 | ON
5308 | 158961 | $lineitem | 13 | bytedict | bytedict | bytedict | ON
5308 | 158961 | $lineitem | 14 | bytedict | bytedict | bytedict | ON
5308 | 158961 | $lineitem | 15 | text255 | text255 | text255 | ON
(16 rows)
```
# STL\$1BCAST
记录有关在执行广播数据的查询步骤期间的网络活动的信息。将按照在对给定切片执行给定步骤期间通过网络发送的行、字节和数据包的数量来捕获网络流量。步骤的持续时间是记录的开始时间与结束时间之差。
要在查询中标识广播步骤，请在 SVL\$1QUERY\$1SUMMARY 视图中查找 bcast 标签或者运行 EXPLAIN 命令，然后查找包括 bcast 的步骤属性。
STL\$1BCAST 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1BCAST 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_BCAST.html)
### 示例查询
以下示例返回查询的广播信息，其中有一个或多个数据包而且查询的开始时间与结束时间之差为一秒或一秒以上。
```
select query, slice, step, rows, bytes, packets, datediff(seconds, starttime, endtime)
from stl_bcast
where packets>0 and datediff(seconds, starttime, endtime)>0;
```
```
query | slice | step | rows | bytes | packets | date_diff
-------+-------+------+------+-------+---------+-----------
453 | 2 | 5 | 1 | 264 | 1 | 1
798 | 2 | 5 | 1 | 264 | 1 | 1
1408 | 2 | 5 | 1 | 264 | 1 | 1
2993 | 0 | 5 | 1 | 264 | 1 | 1
5045 | 3 | 5 | 1 | 264 | 1 | 1
8073 | 3 | 5 | 1 | 264 | 1 | 1
8163 | 3 | 5 | 1 | 264 | 1 | 1
9212 | 1 | 5 | 1 | 264 | 1 | 1
9873 | 1 | 5 | 1 | 264 | 1 | 1
(9 rows)
```
# STL\$1COMMIT\$1STATS
提供与提交性能相关的指标，包括提交的各个阶段的时间和提交的数据块的数量。查询 STL\$1COMMIT\$1STATS 以确定提交时使用的是事务的哪个部分以及出现了多少队列。
STL\$1COMMIT\$1STATS 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_COMMIT_STATS.html)
## 示例查询
```
select node, datediff(ms,startqueue,startwork) as queue_time,
datediff(ms, startwork, endtime) as commit_time, queuelen
from stl_commit_stats
where xid = 2574
order by node;
node | queue_time | commit_time | queuelen
-----+--------------+-------------+---------
-1 | 0 | 617 | 0
0 | 444950725641 | 616 | 0
1 | 444950725636 | 616 | 0
```
# STL\$1CONNECTION\$1LOG
记录身份验证尝试以及连接与断开连接。
STL\$1CONNECTION\$1LOG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_CONNECTION_LOG.html)
## 示例查询
要查看打开连接的详细信息，请运行以下查询。
```
select recordtime, username, dbname, remotehost, remoteport
from stl_connection_log
where event = 'initiating session'
and pid not in
(select pid from stl_connection_log
where event = 'disconnecting session')
order by 1 desc;
recordtime | username | dbname | remotehost | remoteport
--------------------+-------------+------------+---------------+------------
2014-11-06 20:30:06 | rdsdb | dev | [local] |
2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111
2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333
2014-11-05 20:28:35 | rdsdb | dev | [local] |
(4 rows)
```
以下示例反映了一次失败的身份验证尝试和一次成功的连接与断开连接。
```
select event, recordtime, remotehost, username
from stl_connection_log order by recordtime;
event | recordtime | remotehost | username
-----------------------+---------------------------+--------------+---------
authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john
authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john
initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john
disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john
(4 rows)
```
以下示例显示了 ODBC 驱动程序的版本、客户端计算机上的操作系统以及用于连接到 Amazon Redshift 集群的插件。在此示例中，使用的插件用于使用登录名和密码进行标准 ODBC 驱动程序身份验证。
```
select driver_version, os_version, plugin_name from stl_connection_log;
driver_version | os_version | plugin_name
----------------------------------------+-----------------------------------+--------------------
Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none
Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none
```
以下示例显示了客户端计算机上的操作系统版本、驱动程序版本和协议版本。
```
select os_version, driver_version, protocol_version from stl_connection_log;
os_version | driver_version | protocol_version
--------------------------------+------------------------------+--------------------
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
```
# STL\$1DDLTEXT
捕获在系统上运行的以下 DDL 语句。
这些 DDL 语句包括以下查询和对象：
+ CREATE SCHEMA、TABLE、VIEW
+ DROP SCHEMA、TABLE、VIEW
+ ALTER SCHEMA、TABLE
另请参阅 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)、[STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) 和 [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)。这些视图提供了在系统上运行的 SQL 命令的时间表，此历史记录非常适合用于排查问题以及创建所有系统活动的审计跟踪记录。
使用 STARTTIME 和 ENDTIME 列了解在某个给定时间段内记录了哪些语句。SQL 文本的长数据块已分为 200 个字符长的行；SEQUENCE 列标识了属于一个语句的文本片段。
STL\$1DDLTEXT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_DDLTEXT.html)
## 示例查询
以下查询将返回包含以前运行的 DDL 语句的记录。
```
select xid, starttime, sequence, substring(text,1,40) as text
from stl_ddltext order by xid desc, sequence;
```
以下是显示了四个 CREATE TABLE 语句的示例输出。DDL 语句显示在 `text` 列，为方便阅读，该列已被截断。
```
xid | starttime | sequence | text
------+----------------------------+----------+------------------------------------------
1806 | 2013-10-23 00:11:14.709851 | 0 | CREATE TABLE supplier ( s_suppkey int4 N
1806 | 2013-10-23 00:11:14.709851 | 1 | s_comment varchar(101) NOT NULL )
1805 | 2013-10-23 00:11:14.496153 | 0 | CREATE TABLE region ( r_regionkey int4 N
1804 | 2013-10-23 00:11:14.285986 | 0 | CREATE TABLE partsupp ( ps_partkey int8
1803 | 2013-10-23 00:11:14.056901 | 0 | CREATE TABLE part ( p_partkey int8 NOT N
1803 | 2013-10-23 00:11:14.056901 | 1 | ner char(10) NOT NULL , p_retailprice nu
(6 rows)
```
### 重新构造存储的 SQL
以下 SQL 列出了存储在 STL\$1DDLTEXT 的 `text` 列中的行。这些行按 `xid` 和 `sequence` 排序。如果原始 SQL 的长度超过 200 个字符并有多个行，则 STL\$1DDLTEXT 可以按 `sequence` 包含多个行。
```
SELECT xid, sequence, LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') WITHIN GROUP (ORDER BY sequence) as query_statement
FROM stl_ddltext GROUP BY xid, sequence ORDER BY xid, sequence;
```
```
xid | sequence | query_statement
--------+-----------+-----------------
7886671 0 create external schema schema_spectrum_uddh\nfrom data catalog\ndatabase 'spectrum_db_uddh'\niam_role ''\ncreate external database if not exists;
7886752 0 CREATE EXTERNAL TABLE schema_spectrum_uddh.soccer_league\n(\n league_rank smallint,\n prev_rank smallint,\n club_name varchar(15),\n league_name varchar(20),\n league_off decimal(6,2),\n le
7886752 1 ague_def decimal(6,2),\n league_spi decimal(6,2),\n league_nspi smallint\n)\nROW FORMAT DELIMITED \n FIELDS TERMINATED BY ',' \n LINES TERMINATED BY '\\n\\l'\nstored as textfile\nLOCATION 's
7886752 2 3://mybucket-spectrum-uddh/'\ntable properties ('skip.header.line.count'='1');
...
```
要重新构造存储在 STL\$1DDLTEXT 的 `text` 列中的 SQL，请运行以下 SQL 语句。它聚合了 `text` 列中的一个或多个段的 DDL 语句。在运行重新构造的 SQL 之前，将任何 (`\n`) 特殊字符替换为 SQL 客户端中的新行。以下 SELECT 语句的结果按顺序将三个行放在一起，以便在 `query_statement` 字段中重新构建 SQL。
```
SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement
FROM stl_ddltext GROUP BY xid, endtime order by xid, endtime;
```
```
query_statement
--------------
create external schema schema_spectrum_uddh\nfrom data catalog\ndatabase 'spectrum_db_uddh'\niam_role ''\ncreate external database if not exists;
CREATE EXTERNAL TABLE schema_spectrum_uddh.soccer_league\n(\n league_rank smallint,\n prev_rank smallint,\n club_name varchar(15),\n league_name varchar(20),\n league_off decimal(6,2),\n league_def decimal(6,2),\n league_spi decimal(6,2),\n league_nspi smallint\n)\nROW FORMAT DELIMITED \n FIELDS TERMINATED BY ',' \n LINES TERMINATED BY '\\n\\l'\nstored as textfile\nLOCATION 's3://mybucket-spectrum-uddh/'\ntable properties ('skip.header.line.count'='1');
```
# STL\$1DELETE
分析查询的删除执行步骤。
STL\$1DELETE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1DELETE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_DELETE.html)
## 示例查询
为了在 STL\$1DELETE 中创建行，以下示例将一行插入到 EVENT 表中，然后删除该行。
首先，将一行插入到 EVENT 表中并确认已插入该行。
```
insert into event(eventid,venueid,catid,dateid,eventname)
values ((select max(eventid)+1 from event),95,9,1857,'Lollapalooza');
```
```
select * from event
where eventname='Lollapalooza'
order by eventid;
```
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+--------------+---------------------
4274 | 102 | 9 | 1965 | Lollapalooza | 2008-05-01 19:00:00
4684 | 114 | 9 | 2105 | Lollapalooza | 2008-10-06 14:00:00
5673 | 128 | 9 | 1973 | Lollapalooza | 2008-05-01 15:00:00
5740 | 51 | 9 | 1933 | Lollapalooza | 2008-04-17 15:00:00
5856 | 119 | 9 | 1831 | Lollapalooza | 2008-01-05 14:00:00
6040 | 126 | 9 | 2145 | Lollapalooza | 2008-11-15 15:00:00
7972 | 92 | 9 | 2026 | Lollapalooza | 2008-07-19 19:30:00
8046 | 65 | 9 | 1840 | Lollapalooza | 2008-01-14 15:00:00
8518 | 48 | 9 | 1904 | Lollapalooza | 2008-03-19 15:00:00
8799 | 95 | 9 | 1857 | Lollapalooza |
(10 rows)
```
现在，删除您添加到 EVENT 表中的行并确认已删除该行。
```
delete from event
where eventname='Lollapalooza' and eventid=(select max(eventid) from event);
```
```
select * from event
where eventname='Lollapalooza'
order by eventid;
```
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+--------------+---------------------
4274 | 102 | 9 | 1965 | Lollapalooza | 2008-05-01 19:00:00
4684 | 114 | 9 | 2105 | Lollapalooza | 2008-10-06 14:00:00
5673 | 128 | 9 | 1973 | Lollapalooza | 2008-05-01 15:00:00
5740 | 51 | 9 | 1933 | Lollapalooza | 2008-04-17 15:00:00
5856 | 119 | 9 | 1831 | Lollapalooza | 2008-01-05 14:00:00
6040 | 126 | 9 | 2145 | Lollapalooza | 2008-11-15 15:00:00
7972 | 92 | 9 | 2026 | Lollapalooza | 2008-07-19 19:30:00
8046 | 65 | 9 | 1840 | Lollapalooza | 2008-01-14 15:00:00
8518 | 48 | 9 | 1904 | Lollapalooza | 2008-03-19 15:00:00
(9 rows)
```
然后，查询 stl\$1delete 以查看删除的执行步骤。在本示例中，查询返回 300 多行，因此已缩短下面的输出以便于显示。
```
select query, slice, segment, step, tasknum, rows, tbl from stl_delete order by query;
```
```
query | slice | segment | step | tasknum | rows | tbl
-------+-------+---------+------+---------+------+--------
7 | 0 | 0 | 1 | 0 | 0 | 100000
7 | 1 | 0 | 1 | 0 | 0 | 100000
8 | 0 | 0 | 1 | 2 | 0 | 100001
8 | 1 | 0 | 1 | 2 | 0 | 100001
9 | 0 | 0 | 1 | 4 | 0 | 100002
9 | 1 | 0 | 1 | 4 | 0 | 100002
10 | 0 | 0 | 1 | 6 | 0 | 100003
10 | 1 | 0 | 1 | 6 | 0 | 100003
11 | 0 | 0 | 1 | 8 | 0 | 100253
11 | 1 | 0 | 1 | 8 | 0 | 100253
12 | 0 | 0 | 1 | 0 | 0 | 100255
12 | 1 | 0 | 1 | 0 | 0 | 100255
13 | 0 | 0 | 1 | 2 | 0 | 100257
13 | 1 | 0 | 1 | 2 | 0 | 100257
14 | 0 | 0 | 1 | 4 | 0 | 100259
14 | 1 | 0 | 1 | 4 | 0 | 100259
...
```
# STL\$1DISK\$1FULL\$1DIAG
有关磁盘已满时记录的错误的日志信息。
STL\$1DISK\$1FULL\$1DIAG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_DISK_FULL_DIAG.html)
## 示例查询
以下示例返回有磁盘已满错误时存储的数据的详细信息。
```
select * from stl_disk_full_diag
```
以下示例将 `currenttime` 转换为时间戳。
```
select '2000-01-01'::timestamp + (currenttime/1000000.0)* interval '1 second' as currenttime,node_num,query_id,temp_blocks from pg_catalog.stl_disk_full_diag;
```
```
currenttime | node_num | query_id | temp_blocks
----------------------------+----------+----------+-------------
2019-05-18 19:19:18.609338 | 0 | 569399 | 70982
2019-05-18 19:37:44.755548 | 0 | 569580 | 70982
2019-05-20 13:37:20.566916 | 0 | 597424 | 70869
```
# STL\$1DIST
记录有关在执行分配数据的查询步骤期间的网络活动的信息。将按照在对给定切片执行给定步骤期间通过网络发送的行、字节和数据包的数量来捕获网络流量。步骤的持续时间是记录的开始时间与结束时间之差。
要标识查询中的分配步骤，请在 QUERY\$1SUMMARY 视图中查找 dist 标签或者运行 EXPLAIN 命令，然后查找包含 dist 的步骤属性。
STL\$1DIST 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1DIST 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_DIST.html)
## 示例查询
以下示例返回具有一个或多个数据包且持续时间大于零的查询的分配信息。
```
select query, slice, step, rows, bytes, packets,
datediff(seconds, starttime, endtime) as duration
from stl_dist
where packets>0 and datediff(seconds, starttime, endtime)>0
order by query
limit 10;
```
```
query | slice | step | rows | bytes | packets | duration
--------+-------+------+--------+---------+---------+-----------
567 | 1 | 4 | 49990 | 6249564 | 707 | 1
630 | 0 | 5 | 8798 | 408404 | 46 | 2
645 | 1 | 4 | 8798 | 408404 | 46 | 1
651 | 1 | 5 | 192497 | 9226320 | 1039 | 6
669 | 1 | 4 | 192497 | 9226320 | 1039 | 4
675 | 1 | 5 | 3766 | 194656 | 22 | 1
696 | 0 | 4 | 3766 | 194656 | 22 | 1
705 | 0 | 4 | 930 | 44400 | 5 | 1
111525 | 0 | 3 | 68 | 17408 | 2 | 1
(9 rows)
```
# STL\$1ERROR
记录由 Amazon Redshift 数据库引擎生成的内部处理错误。STL\$1ERROR 不记录 SQL 错误或消息。STL\$1ERROR 中的信息对排除某些错误非常有用。AWS Support 工程师可能要求您提供此信息来作为故障排除过程的一部分。
STL\$1ERROR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
有关在使用 Copy 命令加载数据时可生成的错误代码的列表，请参阅[加载错误参考](r_Load_Error_Reference.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_ERROR.html)
## 示例查询
以下示例检索了 STL\$1ERROR 中的错误信息。
```
select process, errcode, linenum as line,
trim(error) as err
from stl_error;
process | errcode | line | err
--------------+---------+------+------------------------------------------------------------------
padbmaster | 8001 | 194 | Path prefix: s3://redshift-downloads/testnulls/venue.txt*
padbmaster | 8001 | 529 | Listing bucket=redshift-downloads prefix=tests/category-csv-quotes
padbmaster | 2 | 190 | database "template0" is not currently accepting connections
padbmaster | 32 | 1956 | pq_flush: could not send data to client: Broken pipe
(4 rows)
```
# STL\$1EXPLAIN
显示已提交供执行的查询的 EXPLAIN 计划。
STL\$1EXPLAIN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1EXPLAIN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1EXPLAIN](SYS_QUERY_EXPLAIN.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_EXPLAIN.html)
## 示例查询
考虑聚合联接查询的以下 EXPLAIN 输出：
```
explain select avg(datediff(day, listtime, saletime)) as avgwait
from sales, listing where sales.listid = listing.listid;
QUERY PLAN
------------------------------------------------------------------------------
XN Aggregate (cost=6350.30..6350.31 rows=1 width=16)
-> XN Hash Join DS_DIST_NONE (cost=47.08..6340.89 rows=3766 width=16)
Hash Cond: ("outer".listid = "inner".listid)
-> XN Seq Scan on listing (cost=0.00..1924.97 rows=192497 width=12)
-> XN Hash (cost=37.66..37.66 rows=3766 width=12)
-> XN Seq Scan on sales (cost=0.00..37.66 rows=3766 width=12)
(6 rows)
```
如果您运行此查询且其查询 ID 为 10，则您可以使用 STL\$1EXPLAIN 表来查看 EXPLAIN 命令返回的同类信息：
```
select query,nodeid,parentid,substring(plannode from 1 for 30),
substring(info from 1 for 20) from stl_explain
where query=10 order by 1,2;
query| nodeid |parentid| substring | substring
-----+--------+--------+--------------------------------+-------------------
10 | 1 | 0 |XN Aggregate (cost=6717.61..6 |
10 | 2 | 1 | -> XN Merge Join DS_DIST_NO | Merge Cond:("outer"
10 | 3 | 2 | -> XN Seq Scan on lis |
10 | 4 | 2 | -> XN Seq Scan on sal |
(4 rows)
```
请考虑以下查询：
```
select event.eventid, sum(pricepaid)
from event, sales
where event.eventid=sales.eventid
group by event.eventid order by 2 desc;
eventid | sum
--------+----------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
...
```
如果此查询的 ID 为 15，则以下系统视图查询返回已完成的计划节点。在这种情况下，将反转节点的顺序以显示执行的实际顺序：
```
select query,nodeid,parentid,substring(plannode from 1 for 56)
from stl_explain where query=15 order by 1, 2 desc;
query|nodeid|parentid| substring
-----+------+--------+--------------------------------------------------------
15 | 8 | 7 | -> XN Seq Scan on eve
15 | 7 | 5 | -> XN Hash(cost=87.98..87.9
15 | 6 | 5 | -> XN Seq Scan on sales(cos
15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos
15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07..
15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871
15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197.
15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87
(8 rows)
```
以下查询检索包含一个窗口函数的任何查询计划的查询 ID：
```
select query, trim(plannode) from stl_explain
where plannode like '%Window%';
query| btrim
-----+------------------------------------------------------------------------
26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
(2 rows)
```
# STL\$1FILE\$1SCAN
返回通过使用 COPY 命令加载数据时 Amazon Redshift 读取的文件。
查询此视图可帮助排查数据加载错误。STL\$1FILE\$1SCAN 可对于精确查找并行数据加载中的问题特别有用，因为并行数据加载通常只需一个 COPY 命令即可加载许多文件。
STL\$1FILE\$1SCAN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1FILE\$1SCAN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_FILE_SCAN.html)
## 示例查询
以下查询检索花费了超过 1,000,000 微秒来让 Amazon Redshift 读取任何文件的名称和加载时间：
```
select trim(name)as name, loadtime from stl_file_scan
where loadtime > 1000000;
```
此查询返回以下示例输出：
```
name | loadtime
---------------------------+----------
listings_pipe.txt | 9458354
allusers_pipe.txt | 2963761
allevents_pipe.txt | 1409135
tickit/listings_pipe.txt | 7071087
tickit/allevents_pipe.txt | 1237364
tickit/allusers_pipe.txt | 2535138
listings_pipe.txt | 6706370
allusers_pipe.txt | 3579461
allevents_pipe.txt | 1313195
tickit/allusers_pipe.txt | 3236060
tickit/listings_pipe.txt | 4980108
(11 rows)
```
# STL\$1HASH
分析查询的哈希执行步骤。
STL\$1HASH 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1HASH 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_HASH.html)
## 示例查询
以下示例返回有关在查询 720 的哈希中使用的分区数量的信息，并指示在磁盘上未运行任何步骤。
```
select slice, rows, bytes, occupied, workmem, num_parts, est_rows, num_blocks_permitted, is_diskbased
from stl_hash
where query=720 and segment=5
order by slice;
```
```
slice | rows | bytes | occupied | workmem | num_parts | est_rows | num_blocks_permitted | is_diskbased
-------+------+--------+----------+----------+-----------+----------+----------------------+--------------
0 | 145 | 585800 | 1 | 88866816 | 16 | 1 | 52 f
1 | 0 | 0 | 0 | 0 | 16 | 1 | 52 f
(2 rows)
```
# STL\$1HASHJOIN
分析查询的哈希联接执行步骤。
STL\$1HASHJOIN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1HASHJOIN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_HASHJOIN.html)
## 示例查询
以下示例返回在查询 720 的哈希联接中使用的分区的数量。
```
select query, slice, tbl, num_parts
from stl_hashjoin
where query=720 limit 10;
```
```
query | slice | tbl | num_parts
-------+-------+-----+-----------
720 | 0 | 243 | 1
720 | 1 | 243 | 1
(2 rows)
```
# STL\$1INSERT
分析查询的插入执行步骤。
STL\$1INSERT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1INSERT 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_INSERT.html)
## 示例查询
以下示例返回最近查询的插入执行步骤。
```
select slice, segment, step, tasknum, rows, tbl
from stl_insert
where query=pg_last_query_id();
```
```
slice | segment | step | tasknum | rows | tbl
-------+---------+------+---------+-------+--------
0 | 2 | 2 | 15 | 24958 | 100548
1 | 2 | 2 | 15 | 25032 | 100548
(2 rows)
```
# STL\$1LIMIT
分析在 SELECT 查询中使用 LIMIT 子句时发生的执行步骤。
STL\$1LIMIT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1LIMIT 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_LIMIT.html)
## 示例查询
为了在 STL\$1LIMIT 中生成行，此示例首先使用 LIMIT 子句对 VENUE 表运行了以下查询。
```
select * from venue
order by 1
limit 10;
```
```
venueid | venuename | venuecity | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park | Bridgeview | IL | 0
2 | Columbus Crew Stadium | Columbus | OH | 0
3 | RFK Stadium | Washington | DC | 0
4 | CommunityAmerica Ballpark | Kansas City | KS | 0
5 | Gillette Stadium | Foxborough | MA | 68756
6 | New York Giants Stadium | East Rutherford | NJ | 80242
7 | BMO Field | Toronto | ON | 0
8 | The Home Depot Center | Carson | CA | 0
9 | Dick's Sporting Goods Park | Commerce City | CO | 0
10 | Pizza Hut Park | Frisco | TX | 0
(10 rows)
```
然后，运行以下查询来查找您已对 VENUE 表运行的最后一个查询的查询 ID。
```
select max(query)
from stl_query;
```
```
max
--------
127128
(1 row)
```
或者，您可以运行以下查询来验证查询 ID 是否对应于之前运行的 LIMIT 查询。
```
select query, trim(querytxt)
from stl_query
where query=127128;
```
```
query | btrim
--------+------------------------------------------
127128 | select * from venue order by 1 limit 10;
(1 row)
```
最后，运行以下查询来返回有关 STL\$1LIMIT 表中的 LIMIT 查询的信息。
```
select slice, segment, step, starttime, endtime, tasknum
from stl_limit
where query=127128
order by starttime, endtime;
```
```
slice | segment | step | starttime | endtime | tasknum
-------+---------+------+----------------------------+----------------------------+---------
1 | 1 | 3 | 2013-09-06 22:56:43.608114 | 2013-09-06 22:56:43.609383 | 15
0 | 1 | 3 | 2013-09-06 22:56:43.608708 | 2013-09-06 22:56:43.609521 | 15
10000 | 2 | 2 | 2013-09-06 22:56:43.612506 | 2013-09-06 22:56:43.612668 | 0
(3 rows)
```
# STL\$1LOAD\$1COMMITS
返回用于跟踪或排查数据加载的信息。
此视图记录了在每个数据文件加载到数据库表中时的进度。
STL\$1LOAD\$1COMMITS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1LOAD\$1COMMITS 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_LOAD_COMMITS.html)
## 示例查询
以下示例返回上次 COPY 操作的详细信息。
```
select query, trim(filename) as file, curtime as updated
from stl_load_commits
where query = pg_last_copy_id();
query | file | updated
-------+----------------------------------+----------------------------
28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486
(1 row)
```
以下查询包含 TICKIT 数据库中初次加载表时的条目：
```
select query, trim(filename), curtime
from stl_load_commits
where filename like '%tickit%' order by query;
```
```
query | btrim | curtime
-------+---------------------------+----------------------------
22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186
22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604
22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472
22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305
22485 | tickit/allevents_pipe.txt | 2013-02-08 20:58:29.99489
22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939
22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491
22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055
22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049
22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502
22603 | tickit/allevents_pipe.txt | 2013-02-08 21:04:14.785124
22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594
(12 rows)
```
向此系统视图的日志文件写入一个记录的事实并不表示加载操作已作为其所属的事务的一部分成功提交。要验证加载提交，请查询 STL\$1UTILITYTEXT 视图并查找与 COPY 事务对应的 COMMIT 记录。例如，此查询基于针对 STL\$1UTILITYTEXT 的子查询联接 STL\$1LOAD\$1COMMITS 和 STL\$1QUERY：
```
select l.query,rtrim(l.filename),q.xid
from stl_load_commits l, stl_query q
where l.query=q.query
and exists
(select xid from stl_utilitytext where xid=q.xid and rtrim("text")='COMMIT');
query | rtrim | xid
-------+---------------------------+-------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
以下示例突出显示 is\$1partial 和 start\$1offset 列值。
```
-- Single large file copy without scan range
SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id();
1
-- Single large uncompressed, delimited file copy with scan range
SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id();
16
-- Scan range offset logging in the file at 64MB boundary.
SELECT start_offset FROM stl_load_commits
WHERE query = pg_last_copy_id() ORDER BY start_offset;
0
67108864
134217728
201326592
268435456
335544320
402653184
469762048
536870912
603979776
671088640
738197504
805306368
872415232
939524096
1006632960
```
# STL\$1LOAD\$1ERRORS
显示所有 Amazon Redshift 加载错误的记录。
STL\$1LOAD\$1ERRORS 包含所有 Amazon Redshift 加载错误的历史记录。有关可能的加载错误和说明的全面列表，请参阅[加载错误参考](r_Load_Error_Reference.md)。
在您查询 STL\$1LOAD\$1ERRORS 以了解有关错误的一般信息后，可查询 [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md) 以获取其他详细信息，如发生解析错误的准确的数据行和列。
STL\$1LOAD\$1ERRORS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1LOAD\$1ERRORS 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_LOAD_ERRORS.html)
## 示例查询
以下查询将 STL\$1LOAD\$1ERRORS 联接到 STL\$1LOADERROR\$1DETAIL 以查看最近加载期间发生的错误的详细信息。
```
select d.query, substring(d.filename,14,20),
d.line_number as line,
substring(d.value,1,16) as value,
substring(le.err_reason,1,48) as err_reason
from stl_loaderror_detail d, stl_load_errors le
where d.query = le.query
and d.query = pg_last_copy_id();
query | substring | line | value | err_reason
-------+-------------------+------+----------+----------------------------
558| allusers_pipe.txt | 251 | 251 | String contains invalid or
unsupported UTF8 code
558| allusers_pipe.txt | 251 | ZRU29FGR | String contains invalid or
unsupported UTF8 code
558| allusers_pipe.txt | 251 | Kaitlin | String contains invalid or
unsupported UTF8 code
558| allusers_pipe.txt | 251 | Walter | String contains invalid or
unsupported UTF8 code
```
以下示例结合使用 STL\$1LOAD\$1ERRORS 和 STV\$1TBL\$1PERM 来创建新视图，然后使用该视图来确定在将数据加载到 EVENT 表中时发生的错误：
```
create view loadview as
(select distinct tbl, trim(name) as table_name, query, starttime,
trim(filename) as input, line_number, colname, err_code,
trim(err_reason) as reason
from stl_load_errors sl, stv_tbl_perm sp
where sl.tbl = sp.id);
```
接下来，以下查询实际返回在加载 EVENT 表时发生的最后一个错误：
```
select table_name, query, line_number, colname, starttime,
trim(reason) as error
from loadview
where table_name ='event'
order by line_number limit 1;
```
查询返回 EVENT 表发生的最后一个加载错误。如果未发生任何加载错误，则查询返回零行。在此示例中，查询返回一个错误：
```
table_name | query | line_number | colname | error | starttime
------+-----+----+----+--------------------------------------------------------+----------------------
event | 309 | 0 | 5 | Error in Timestamp value or format [%Y-%m-%d %H:%M:%S] | 2014-04-22 15:12:44
(1 row)
```
在 COPY 命令自动拆分大的、未压缩的、以文本分隔的文件数据以促进并行化的情况下，*line\$1number*、*is\$1partial* 和 *start\$1offset* 列显示与拆分有关的信息。（在原始文件中行号不可用的情况下，行号可能是未知的。）
```
--scan ranges information
SELECT line_number, POSITION, btrim(raw_line), btrim(raw_field_value),
btrim(err_reason), is_partial, start_offset FROM stl_load_errors
WHERE query = pg_last_copy_id();
--result
-1,51,"1008771|13463413|463414|2|28.00|38520.72|0.06|0.07|NO|1998-08-30|1998-09-25|1998-09-04|TAKE BACK RETURN|RAIL|ans cajole sly","NO","Char length exceeds DDL length",1,67108864
```
# STL\$1LOADERROR\$1DETAIL
显示使用 COPY 命令加载表时发生的数据解析错误的日志记录。为了节省磁盘空间，对于每个加载操作，每个节点切片最多记录 20 个错误。
在将数据行中的某个字段加载到表时，如果 Amazon Redshift 无法解析该字段，则会发生解析错误。例如，如果表列应为整数数据类型，而且数据文件包含该字段中的字母字符串，则它会导致解析错误。
在您查询 [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) 以了解有关错误的一般信息之后，请查询 STL\$1LOADERROR\$1DETAIL 以获取其他详细信息，如发生解析错误的准确的数据行和列。
STL\$1LOADERROR\$1DETAIL 视图包含所有数据列，其中包括解析错误发生的列及其之前的列。使用 VALUE 字段来查看实际已在此列（包括在发生此错误之前已正确解析的列）中解析的数据值。
此视图对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1LOADERROR\$1DETAIL 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_LOADERROR_DETAIL.html)
## 示例查询
以下查询将 STL\$1LOAD\$1ERRORS 联接到 STL\$1LOADERROR\$1DETAIL 以查看加载 EVENT 表（表 ID 为 100133）时发生的解析错误的详细信息：
```
select d.query, d.line_number, d.value,
le.raw_line, le.err_reason
from stl_loaderror_detail d, stl_load_errors le
where
d.query = le.query
and tbl = 100133;
```
以下示例输出显示已加载成功的列，包括存在错误的列。在此示例中，在第三个列中发生解析错误之前已成功加载两个列，第三个列中应为整数的字段不正确地解析为了字符串。由于该字段应为整数，因此它将字符串“aaa”（未初始化的数据）解析为了 null 并生成了解析错误。输出显示原始值、解析的值和错误原因：
```
query | line_number | value | raw_line | err_reason
-------+-------------+-------+----------+----------------
4 | 3 | 1201 | 1201 | Invalid digit
4 | 3 | 126 | 126 | Invalid digit
4 | 3 | | aaa | Invalid digit
(3 rows)
```
当查询联接 STL\$1LOAD\$1ERRORS 和 STL\$1LOADERROR\$1DETAIL 时，它将显示数据行中每列的错误原因，这只是意味着该行中发生了错误。结果中的最后一行是发生解析错误的实际列。
# STL\$1MERGE
分析查询的合并执行步骤。在合并并行操作（如排序和联接）的结果以进行后续处理时，将会发生这些步骤。
STL\$1MERGE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1MERGE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_MERGE.html)
## 示例查询
以下示例返回 10 个合并执行结果。
```
select query, step, starttime, endtime, tasknum, rows
from stl_merge
limit 10;
```
```
query | step | starttime | endtime | tasknum | rows
-------+------+---------------------+---------------------+---------+------
9 | 0 | 2013-08-12 20:08:14 | 2013-08-12 20:08:14 | 0 | 0
12 | 0 | 2013-08-12 20:09:10 | 2013-08-12 20:09:10 | 0 | 0
15 | 0 | 2013-08-12 20:10:24 | 2013-08-12 20:10:24 | 0 | 0
20 | 0 | 2013-08-12 20:11:27 | 2013-08-12 20:11:27 | 0 | 0
26 | 0 | 2013-08-12 20:12:28 | 2013-08-12 20:12:28 | 0 | 0
32 | 0 | 2013-08-12 20:14:33 | 2013-08-12 20:14:33 | 0 | 0
38 | 0 | 2013-08-12 20:16:43 | 2013-08-12 20:16:43 | 0 | 0
44 | 0 | 2013-08-12 20:17:05 | 2013-08-12 20:17:05 | 0 | 0
50 | 0 | 2013-08-12 20:18:48 | 2013-08-12 20:18:48 | 0 | 0
56 | 0 | 2013-08-12 20:20:48 | 2013-08-12 20:20:48 | 0 | 0
(10 rows)
```
# STL\$1MERGEJOIN
分析查询的合并联接步骤。
STL\$1MERGEJOIN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1MERGEJOIN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_MERGEJOIN.html)
## 示例查询
以下示例返回最近查询的合并联接结果。
```
select sum(s.qtysold), e.eventname
from event e, listing l, sales s
where e.eventid=l.eventid
and l.listid= s.listid
group by e.eventname;
select * from stl_mergejoin where query=pg_last_query_id();
```
```
userid | query | slice | segment | step | starttime | endtime | tasknum | rows | tbl
--------+-------+-------+---------+------+---------------------+---------------------+---------+------+-----
100 | 27399 | 3 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43428 | 240
100 | 27399 | 0 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43159 | 240
100 | 27399 | 2 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |42778 | 240
100 | 27399 | 1 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43091 | 240
```
# STL\$1MV\$1STATE
STL\$1MV\$1STATE 视图对于实体化视图的每次状态转换包含一行。
有关实体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
STL\$1MV\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1MV\$1STATE](SYS_MV_STATE.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_MV_STATE.html)
下表显示了 `event_desc` 和 `state` 的示例组合。
```
event_desc | state
-------------------------+---------------
TRUNCATE | Recompute
TRUNCATE | Recompute
Small table conversion | Recompute
Vacuum | Recompute
Column was renamed | Unrefreshable
Column was dropped | Unrefreshable
Table was renamed | Unrefreshable
Column type was changed | Unrefreshable
Schema name was changed | Unrefreshable
```
## 示例查询
要查看实体化视图的状态转换的日志，请运行以下查询。
```
select * from stl_mv_state;
```
此查询返回以下示例输出：
```
userid | starttime | xid | event_desc | db_name | base_table_schema | base_table_name | mv_schema | mv_name | state
--------+----------------------------+------+-----------------------------+---------+----------------------+----------------------+----------------------+---------------+---------------
138 | 2020-02-14 02:21:25.578885 | 5180 | TRUNCATE | dev | public | mv_base_table | public | mv_test | Recompute
138 | 2020-02-14 02:21:56.846774 | 5275 | Column was dropped | dev | | mv_base_table | public | mv_test | Unrefreshable
100 | 2020-02-13 22:09:53.041228 | 1794 | Column was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable
1 | 2020-02-13 22:10:23.630914 | 1893 | ALTER TABLE ALTER SORTKEY | dev | public | mv_base_table_sorted | public | mv_test | Recompute
1 | 2020-02-17 22:57:22.497989 | 8455 | ALTER TABLE ALTER DISTSTYLE | dev | public | mv_base_table | public | mv_test | Recompute
173 | 2020-02-17 22:57:23.591434 | 8504 | Table was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable
173 | 2020-02-17 22:57:27.229423 | 8592 | Column type was changed | dev | | mv_base_table | public | mv_test | Unrefreshable
197 | 2020-02-17 22:59:06.212569 | 9668 | TRUNCATE | dev | schemaf796e415850f4f | mv_base_table | schemaf796e415850f4f | mv_test | Recompute
138 | 2020-02-14 02:21:55.705655 | 5226 | Column was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable
1 | 2020-02-14 02:22:26.292434 | 5325 | ALTER TABLE ALTER SORTKEY | dev | public | mv_base_table_sorted | public | mv_test | Recompute
```
# STL\$1NESTLOOP
分析查询的嵌套循环的联接执行步骤。
STL\$1NESTLOOP 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1NESTLOOP 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_NESTLOOP.html)
## 示例查询
由于以下查询忽略了联接 CATEGORY 表，因此它会生成一个部分笛卡尔积（不推荐这样做）。这里只是为了说明嵌套循环。
```
select count(event.eventname), event.eventname, category.catname, date.caldate
from event, category, date
where event.dateid = date.dateid
group by event.eventname, category.catname, date.caldate;
```
以下查询显示来自 STL\$1NESTLOOP 视图中的上个查询的结果。
```
select query, slice, segment as seg, step,
datediff(msec, starttime, endtime) as duration, tasknum, rows, tbl
from stl_nestloop
where query = pg_last_query_id();
```
```
query | slice | seg | step | duration | tasknum | rows | tbl
-------+-------+-----+------+----------+---------+-------+-----
6028 | 0 | 4 | 5 | 41 | 22 | 24277 | 240
6028 | 1 | 4 | 5 | 26 | 23 | 24189 | 240
6028 | 3 | 4 | 5 | 25 | 23 | 24376 | 240
6028 | 2 | 4 | 5 | 54 | 22 | 23936 | 240
```
# STL\$1PARSE
分析将字符串解析为二进制值以进行加载的查询步骤。
STL\$1PARSE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1PARSE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_PARSE.html)
## 示例查询
以下示例返回切片 1 和分段 0 的所有查询步骤结果，其中的字符串已解析为二进制值。
```
select query, step, starttime, endtime, tasknum, rows
from stl_parse
where slice=1 and segment=0;
```
```
query | step | starttime | endtime | tasknum | rows
-------+------+---------------------+---------------------+---------+--------
669 | 1 | 2013-08-12 22:35:13 | 2013-08-12 22:35:17 | 32 | 192497
696 | 1 | 2013-08-12 22:35:49 | 2013-08-12 22:35:49 | 32 | 0
525 | 1 | 2013-08-12 22:32:03 | 2013-08-12 22:32:03 | 13 | 49990
585 | 1 | 2013-08-12 22:33:18 | 2013-08-12 22:33:19 | 13 | 202
621 | 1 | 2013-08-12 22:34:03 | 2013-08-12 22:34:03 | 27 | 365
651 | 1 | 2013-08-12 22:34:47 | 2013-08-12 22:34:53 | 35 | 192497
590 | 1 | 2013-08-12 22:33:28 | 2013-08-12 22:33:28 | 19 | 0
599 | 1 | 2013-08-12 22:33:39 | 2013-08-12 22:33:39 | 31 | 11
675 | 1 | 2013-08-12 22:35:26 | 2013-08-12 22:35:27 | 38 | 3766
567 | 1 | 2013-08-12 22:32:47 | 2013-08-12 22:32:48 | 23 | 49990
630 | 1 | 2013-08-12 22:34:17 | 2013-08-12 22:34:17 | 36 | 0
572 | 1 | 2013-08-12 22:33:04 | 2013-08-12 22:33:04 | 29 | 0
645 | 1 | 2013-08-12 22:34:37 | 2013-08-12 22:34:38 | 29 | 8798
604 | 1 | 2013-08-12 22:33:47 | 2013-08-12 22:33:47 | 37 | 0
(14 rows)
```
# STL\$1PLAN\$1INFO
使用 STL\$1PLAN\$1INFO 视图以一组行的形式查看一个查询的 EXPLAIN 输出。这是查看查询计划的一种替代方法。
STL\$1PLAN\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1PLAN\$1INFO 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_PLAN_INFO.html)
## 示例查询
以下示例比较了通过使用 EXPLAIN 命令和通过查询 STL\$1PLAN\$1INFO 视图返回的简单 SELECT 查询的查询计划。
```
explain select * from category;
QUERY PLAN
-------------------------------------------------------------
XN Seq Scan on category (cost=0.00..0.11 rows=11 width=49)
(1 row)
select * from category;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
1 | Sports | MLB | Major League Baseball
3 | Sports | NFL | National Football League
5 | Sports | MLS | Major League Soccer
...
select * from stl_plan_info where query=256;
query | nodeid | segment | step | locus | plannode | startupcost | totalcost
| rows | bytes
-------+--------+---------+------+-------+----------+-------------+-----------+------+-------
256 | 1 | 0 | 1 | 0 | 104 | 0 | 0.11 | 11 | 539
256 | 1 | 0 | 0 | 0 | 104 | 0 | 0.11 | 11 | 539
(2 rows)
```
在本示例中，PLANNODE 104 表示 CATEGORY 表的顺序扫描。
```
select distinct eventname from event order by 1;
eventname
------------------------------------------------------------------------
.38 Special
3 Doors Down
70s Soul Jam
A Bronx Tale
...
explain select distinct eventname from event order by 1;
QUERY PLAN
-------------------------------------------------------------------------------------
XN Merge (cost=1000000000136.38..1000000000137.82 rows=576 width=17)
Merge Key: eventname
-> XN Network (cost=1000000000136.38..1000000000137.82 rows=576
width=17)
Send to leader
-> XN Sort (cost=1000000000136.38..1000000000137.82 rows=576
width=17)
Sort Key: eventname
-> XN Unique (cost=0.00..109.98 rows=576 width=17)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798
width=17)
(8 rows)
select * from stl_plan_info where query=240 order by nodeid desc;
query | nodeid | segment | step | locus | plannode | startupcost |
totalcost | rows | bytes
-------+--------+---------+------+-------+----------+------------------+------------------+------+--------
240 | 5 | 0 | 0 | 0 | 104 | 0 | 87.98 | 8798 | 149566
240 | 5 | 0 | 1 | 0 | 104 | 0 | 87.98 | 8798 | 149566
240 | 4 | 0 | 2 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 0 | 3 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 1 | 0 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 1 | 1 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 3 | 1 | 2 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 3 | 2 | 0 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 2 | 2 | 1 | 0 | 123 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 1 | 3 | 0 | 0 | 122 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
(10 rows)
```
# STL\$1PROJECT
包含用于计算表达式的查询步骤的行。
STL\$1PROJECT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1PROJECT 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_PROJECT.html)
## 示例查询
以下示例返回已用于计算切片 0 和分段 1 的表达式的查询步骤的所有行。
```
select query, step, starttime, endtime, tasknum, rows
from stl_project
where slice=0 and segment=1;
```
```
query | step | starttime | endtime | tasknum | rows
--------+------+---------------------+---------------------+---------+------
86399 | 2 | 2013-08-29 22:01:21 | 2013-08-29 22:01:21 | 25 | -1
86399 | 3 | 2013-08-29 22:01:21 | 2013-08-29 22:01:21 | 25 | -1
719 | 1 | 2013-08-12 22:38:33 | 2013-08-12 22:38:33 | 7 | -1
86383 | 1 | 2013-08-29 21:58:35 | 2013-08-29 21:58:35 | 7 | -1
714 | 1 | 2013-08-12 22:38:17 | 2013-08-12 22:38:17 | 2 | -1
86375 | 1 | 2013-08-29 21:57:59 | 2013-08-29 21:57:59 | 2 | -1
86397 | 2 | 2013-08-29 22:01:20 | 2013-08-29 22:01:20 | 19 | -1
627 | 1 | 2013-08-12 22:34:13 | 2013-08-12 22:34:13 | 34 | -1
86326 | 2 | 2013-08-29 21:45:28 | 2013-08-29 21:45:28 | 34 | -1
86326 | 3 | 2013-08-29 21:45:28 | 2013-08-29 21:45:28 | 34 | -1
86325 | 2 | 2013-08-29 21:45:27 | 2013-08-29 21:45:27 | 28 | -1
86371 | 1 | 2013-08-29 21:57:42 | 2013-08-29 21:57:42 | 4 | -1
111100 | 2 | 2013-09-03 19:04:45 | 2013-09-03 19:04:45 | 12 | -1
704 | 2 | 2013-08-12 22:36:34 | 2013-08-12 22:36:34 | 37 | -1
649 | 2 | 2013-08-12 22:34:47 | 2013-08-12 22:34:47 | 38 | -1
649 | 3 | 2013-08-12 22:34:47 | 2013-08-12 22:34:47 | 38 | -1
632 | 2 | 2013-08-12 22:34:22 | 2013-08-12 22:34:22 | 13 | -1
705 | 2 | 2013-08-12 22:36:48 | 2013-08-12 22:36:49 | 13 | -1
705 | 3 | 2013-08-12 22:36:48 | 2013-08-12 22:36:49 | 13 | -1
3 | 1 | 2013-08-12 20:07:40 | 2013-08-12 20:07:40 | 3 | -1
86373 | 1 | 2013-08-29 21:57:58 | 2013-08-29 21:57:58 | 3 | -1
107976 | 1 | 2013-09-03 04:05:12 | 2013-09-03 04:05:12 | 3 | -1
86381 | 1 | 2013-08-29 21:58:35 | 2013-08-29 21:58:35 | 8 | -1
86396 | 1 | 2013-08-29 22:01:20 | 2013-08-29 22:01:20 | 15 | -1
711 | 1 | 2013-08-12 22:37:10 | 2013-08-12 22:37:10 | 20 | -1
86324 | 1 | 2013-08-29 21:45:27 | 2013-08-29 21:45:27 | 24 | -1
(26 rows)
```
# STL\$1QUERY
返回有关数据库查询的执行信息。
**注意**
STL\$1QUERY 和 STL\$1QUERYTEXT 视图仅包含有关查询的信息，不包含有关其他实用工具和 DDL 命令的信息。对于有关 Amazon Redshift 运行的所有语句的列表和信息，您还可以查询 STL\$1DDLTEXT 和 STL\$1UTILITYTEXT 视图。有关 Amazon Redshift 运行的所有语句的完整列表，您可以查询 SVL\$1STATEMENTTEXT 视图。
STL\$1QUERY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
请注意，当查询文本长度超过 4000 个字符时，STL\$1QUERY 仅显示截断的数据。要获取完整的查询文本，可以对各行的查询文本使用 UNION。
**注意**
要验证包含已执行查询的事务是否成功提交，您需要在系统表和 `sys_transaction_history` 表之间执行联接操作。例如：
```
SELECT
stlq.xid AS transaction_id,
stlq.query AS query_id,
TRIM(stlq.querytxt) AS query_text,
th.status AS transaction_status
FROM
stl_query stlq
LEFT JOIN
sys_transaction_history th ON stlq.xid = th.transaction_id;
```
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_QUERY.html)
## 示例查询
以下示例列出最近的 5 个查询。
```
select query, trim(querytxt) as sqlquery
from stl_query
order by query desc limit 5;
query | sqlquery
------+--------------------------------------------------
129 | select query, trim(querytxt) from stl_query order by query;
128 | select node from stv_disk_read_speeds;
127 | select system_status from stv_gui_status
126 | select * from systable_topology order by slice
125 | load global dict registry
(5 rows)
```
以下查询按降序返回在 2013 年 2 月 15 日运行的查询所消耗的时间。
```
select query, datediff(seconds, starttime, endtime),
trim(querytxt) as sqlquery
from stl_query
where starttime >= '2013-02-15 00:00' and endtime < '2013-02-16 00:00'
order by date_diff desc;
query | date_diff | sqlquery
-------+-----------+-------------------------------------------
55 | 119 | padb_fetch_sample: select count(*) from category
121 | 9 | select * from svl_query_summary;
181 | 6 | select * from svl_query_summary where query in(179,178);
172 | 5 | select * from svl_query_summary where query=148;
...
(189 rows)
```
以下查询显示查询的队列时间和执行时间。`concurrency_scaling_status = 1` 的查询运行在并发扩展集群上。所有其他查询都运行在主集群上。
```
SELECT w.service_class AS queue
, q.concurrency_scaling_status
, COUNT( * ) AS queries
, SUM( q.aborted ) AS aborted
, SUM( ROUND( total_queue_time::NUMERIC / 1000000,2 ) ) AS queue_secs
, SUM( ROUND( total_exec_time::NUMERIC / 1000000,2 ) ) AS exec_secs
FROM stl_query q
JOIN stl_wlm_query w
USING (userid,query)
WHERE q.userid > 1
AND service_class > 5
AND q.starttime > '2019-03-01 16:38:00'
AND q.endtime < '2019-03-01 17:40:00'
GROUP BY 1,2
ORDER BY 1,2;
```
# STL\$1QUERY\$1METRICS
包含已完成在用户定义的查询队列中运行的查询的指标信息（如处理的行数、CPU 利用率、输入/输出和磁盘利用率）。要查看当前运行的活动查询的指标，请参阅 [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md) 系统视图。
查询指标按一秒的间隔采样。因此，同一查询的不同运行可能返回稍微不同的时间。此外，运行不到 1 秒的查询段可能不会记录。
STL\$1QUERY\$1METRICS 可跟踪和聚合查询、段和步骤级别的指标。有关查询段和步骤的信息，请参阅[查询计划和执行工作流程](c-query-planning.md)。很多指标（如 `max_rows`、`cpu_time` 等）是跨节点切片进行合计的。有关节点切片的更多信息，请参阅[数据仓库系统架构](c_high_level_system_architecture.md)。
要确定行在哪个级别报告指标，请检查 `segment` 和 `step_type` 列。
+ 如果 `segment` 和 `step_type` 均为 `-1`，则行在查询级别报告指标。
+ 如果 `segment` 不为 `-1`，而 `step_type` 为 `-1`，则行在段级别报告指标。
+ 如果 `segment` 和 `step_type` 均不为 `-1`，则行在步骤级别报告指标。
[SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md) 视图和 [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md) 视图将聚合此视图中的数据并以更容易访问的形式呈现信息。
STL\$1QUERY\$1METRICS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_QUERY_METRICS.html)
## 示例查询
要查找具有较长的 CPU 时间（1000 秒以上）的查询，请运行以下查询。
```
Select query, cpu_time / 1000000 as cpu_seconds
from stl_query_metrics where segment = -1 and cpu_time > 1000000000
order by cpu_time;
query | cpu_seconds
------+------------
25775 | 9540
```
要查找具有返回超过一百万个行的嵌套循环联接的活动查询，请运行以下查询。
```
select query, rows
from stl_query_metrics
where step_type = 15 and rows > 1000000
order by rows;
query | rows
------+-----------
25775 | 2621562702
```
要查找已运行超过 60 秒且使用的 CPU 时间不到 10 秒的活动查询，请运行以下查询。
```
select query, run_time/1000000 as run_time_seconds
from stl_query_metrics
where segment = -1 and run_time > 60000000 and cpu_time < 10000000;
query | run_time_seconds
------+-----------------
25775 | 114
```
# STL\$1QUERYTEXT
捕获 SQL 命令的查询文本。
查询 STL\$1QUERYTEXT 视图以捕获为以下语句记录的 SQL：
+ SELECT、SELECT INTO
+ INSERT、UPDATE、DELETE
+ COPY
+ UNLOAD
+ 运行 VACUUM 和 ANALYZE 生成的查询
+ CREATE TABLE AS (CTAS)
要查询某个给定时间段中针对这些语句的活动，请联接 STL\$1QUERYTEXT 和 STL\$1QUERY 视图。
**注意**
STL\$1QUERY 和 STL\$1QUERYTEXT 视图仅包含有关查询的信息，不包含有关其他实用工具和 DDL 命令的信息。对于有关 Amazon Redshift 运行的所有语句的列表和信息，您还可以查询 STL\$1DDLTEXT 和 STL\$1UTILITYTEXT 视图。有关 Amazon Redshift 运行的所有语句的完整列表，您可以查询 SVL\$1STATEMENTTEXT 视图。
另请参阅 [STL\$1DDLTEXT](r_STL_DDLTEXT.md)、[STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) 和 [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)。
STL\$1QUERYTEXT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
请注意，当查询文本长度超过 4000 个字符时，STL\$1QUERYTEXT 仅显示截断的数据。要获取完整的查询文本，可以对各行的查询文本使用 UNION。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_QUERYTEXT.html)
## 示例查询
您可以使用 PG\$1BACKEND\$1PID() 函数检索当前会话的信息。例如，以下查询返回当前会话中完成的查询的查询 ID 和一部分查询文本。
```
select query, substring(text,1,60)
from stl_querytext
where pid = pg_backend_pid()
order by query desc;
query | substring
-------+--------------------------------------------------------------
28262 | select query, substring(text,1,80) from stl_querytext where
28252 | select query, substring(path,0,80) as path from stl_unload_l
28248 | copy category from 's3://dw-tickit/manifest/category/1030_ma
28247 | Count rows in target table
28245 | unload ('select * from category') to 's3://dw-tickit/manifes
28240 | select query, substring(text,1,40) from stl_querytext where
(6 rows)
```
### 重新构造存储的 SQL
要重新构造存储在 STL\$1QUERYTEXT 的`text` 列中的 SQL，请运行 SELECT 语句，以从 `text` 列中的一个或多个部分创建 SQL。在运行重新构造的 SQL 之前，将任何 (`\n`) 特殊字符替换为新行。以下 SELECT 语句的结果是 `query_statement` 字段中重新构造的 SQL 的行。
```
SELECT query, LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement, COUNT(*) as row_count
FROM stl_querytext GROUP BY query ORDER BY query desc;
```
例如，以下查询选择 3 列。查询本身超过 200 个字符，并存储在 STL\$1QUERYTEXT 中的几个部分内。
```
select
1 AS a0123456789012345678901234567890123456789012345678901234567890,
2 AS b0123456789012345678901234567890123456789012345678901234567890,
3 AS b012345678901234567890123456789012345678901234
FROM stl_querytext;
```
在此示例中，查询存储在 STL\$1QUERYTEXT 的 `text` 列的 2 个部分（行）中。
```
select query, sequence, text
from stl_querytext where query=pg_last_query_id() order by query desc, sequence limit 10;
```
```
query | sequence | text
-------+----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
45 | 0 | select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234
45 | 1 | \nFROM stl_querytext;
```
要重新构造存储在 STL\$1QUERYTEXT 中的 SQL，请运行以下 SQL。
```
select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS text
from stl_querytext where query=pg_last_query_id();
```
要在客户端中使用生成的重新构造的 SQL，需将任何 (`\n`) 特殊字符替换为新行。
```
text
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234\nFROM stl_querytext;
```
# STL\$1REPLACEMENTS
显示当无效的 UTF-8 字符由带有 ACCEPTINVCHARS 选项的 [COPY](r_COPY.md) 命令替换时所记录的日志。对于每个至少需要一次替换的节点切片上的前 100 行，将为每个行向 STL\$1REPLACEMENTS 添加一个日志条目。
STL\$1REPLACEMENTS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1NESTLOOP 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_REPLACEMENTS.html)
## 示例查询
以下示例返回最近的 COPY 操作中的替换。
```
select query, session, filename, line_number, colname
from stl_replacements
where query = pg_last_copy_id();
query | session | filename | line_number | colname
------+---------+---------------------------------------------+-------------+--------
96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 251 | city
96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 317 | city
96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 569 | city
96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 623 | city
96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 694 | city
...
```
# STL\$1RESTARTED\$1SESSIONS
为了在发生特定内部事件后保持连续可用性，Amazon Redshift 可能会重新启动具有新进程 ID (PID) 的活动会话。在 Amazon Redshift 重新启动会话时，STL\$1RESTARTED\$1SESSIONS 将记录新 PID 和旧 PID。
有关更多信息，请参阅本部分中后面的示例。
STL\$1RESTARTED\$1SESSIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_RESTARTED_SESSIONS.html)
## 示例查询
以下示例将 STL\$1RESTARTED\$1SESSIONS 与 STL\$1SESSIONS 联接以显示已重新启动的会话的用户名。
```
select process, stl_restarted_sessions.newpid, user_name
from stl_sessions
inner join stl_restarted_sessions on stl_sessions.process = stl_restarted_sessions.oldpid
order by process;
...
```
# STL\$1RETURN
包含查询中的*返回* 步骤的详细信息。返回步骤将在计算节点上完成的查询的结果返回到领导节点。然后，领导节点合并数据并将结果返回至请求客户端。对于在领导节点上完成的查询，返回步骤将结果返回至客户端。
一个查询包含多个区段，而且每个区段包含一个或多个步骤。有关更多信息，请参阅 [查询处理](c-query-processing.md)。
STL\$1RETURN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1RETURN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_RETURN.html)
## 示例查询
以下示例查询显示最近查询中在每个切片上执行的步骤。
```
SELECT query, slice, segment, step, endtime, rows, packets
from stl_return where query = pg_last_query_id();
query | slice | segment | step | endtime | rows | packets
-------+--------+---------+------+----------------------------+------+---------
4 | 2 | 3 | 2 | 2013-12-27 01:43:21.469043 | 3 | 0
4 | 3 | 3 | 2 | 2013-12-27 01:43:21.473321 | 0 | 0
4 | 0 | 3 | 2 | 2013-12-27 01:43:21.469118 | 2 | 0
4 | 1 | 3 | 2 | 2013-12-27 01:43:21.474196 | 0 | 0
4 | 4 | 3 | 2 | 2013-12-27 01:43:21.47704 | 2 | 0
4 | 5 | 3 | 2 | 2013-12-27 01:43:21.478593 | 0 | 0
4 | 12811| 4 | 1 | 2013-12-27 01:43:21.480755 | 0 | 0
(7 rows)
```
# STL\$1S3CLIENT
记录传输时间和其他性能指标。
使用 STL\$1S3CLIENT 表可查找传输 Amazon S3 中的数据所花费的时间。
STL\$1S3CLIENT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_S3CLIENT.html)
## 示例查询
以下查询返回使用 COPY 命令加载文件花费的时间。
```
select slice, key, transfer_time
from stl_s3client
where query = pg_last_copy_id();
```
结果
```
slice | key | transfer_time
------+-----------------------------+---------------
0 | listing10M0003_part_00 | 16626716
1 | listing10M0001_part_00 | 12894494
2 | listing10M0002_part_00 | 14320978
3 | listing10M0000_part_00 | 11293439
3371 | prefix=listing10M;marker= | 99395
```
以下示例将 `start_time` 和 `end_time` 转换为时间戳。
```
select userid,query,slice,pid,recordtime,start_time,end_time,
'2000-01-01'::timestamp + (start_time/1000000.0)* interval '1 second' as start_ts,
'2000-01-01'::timestamp + (end_time/1000000.0)* interval '1 second' as end_ts
from stl_s3client where query> -1 limit 5;
```
```
userid | query | slice | pid | recordtime | start_time | end_time | start_ts | end_ts
--------+-------+-------+-------+----------------------------+-----------------+-----------------+----------------------------+----------------------------
0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.207839 | 616436837154256 | 616436837207838 | 2019-07-14 16:27:17.154256 | 2019-07-14 16:27:17.207838
0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.252521 | 616436837208208 | 616436837252520 | 2019-07-14 16:27:17.208208 | 2019-07-14 16:27:17.25252
0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.284376 | 616436837208460 | 616436837284374 | 2019-07-14 16:27:17.20846 | 2019-07-14 16:27:17.284374
0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.285307 | 616436837208980 | 616436837285306 | 2019-07-14 16:27:17.20898 | 2019-07-14 16:27:17.285306
0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.353853 | 616436837302216 | 616436837353851 | 2019-07-14 16:27:17.302216 | 2019-07-14 16:27:17.353851
```
# STL\$1S3CLIENT\$1ERROR
记录从 Amazon S3 加载文件时切片遇到的错误。
使用 STL\$1S3CLIENT\$1ERROR 来查找在从 Amazon S3 传输数据（作为 COPY 命令的一部分）时遇到的错误的详细信息。
STL\$1S3CLIENT\$1ERROR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_S3CLIENT_ERROR.html)
## 使用说明
如果您看到多个包含“Connection timed out”的错误，您可能遇到了联网问题。如果您使用的是增强型 VPC 路由，请确认您在集群的 VPC 与数据资源之间具有有效的网络路径。有关更多信息，请参阅 [Amazon Redshift 增强型 VPC 路由](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html)。
## 示例查询
以下查询返回当前会话期间完成的 COPY 命令中的错误。
```
select query, sliceid, substring(key from 1 for 20) as file,
substring(error from 1 for 35) as error
from stl_s3client_error
where pid = pg_backend_pid()
order by query desc;
```
结果
```
query | sliceid | file | error
--------+---------+--------------------+------------------------------------
362228 | 12 | part.tbl.25.159.gz | transfer closed with 1947655 bytes
362228 | 24 | part.tbl.15.577.gz | transfer closed with 1881910 bytes
362228 | 7 | part.tbl.22.600.gz | transfer closed with 700143 bytes r
362228 | 22 | part.tbl.3.34.gz | transfer closed with 2334528 bytes
362228 | 11 | part.tbl.30.274.gz | transfer closed with 699031 bytes r
362228 | 30 | part.tbl.5.509.gz | Unknown SSL protocol error in conne
361999 | 10 | part.tbl.23.305.gz | transfer closed with 698959 bytes r
361999 | 19 | part.tbl.26.582.gz | transfer closed with 1881458 bytes
361999 | 4 | part.tbl.15.629.gz | transfer closed with 2275907 bytes
361999 | 20 | part.tbl.6.456.gz | transfer closed with 692162 bytes r
(10 rows)
```
# STL\$1SAVE
包含查询中的*保存* 步骤的详细信息。保存步骤将输入流保存到一个临时表。临时表是查询执行期间存储中间结果的临时表。
一个查询包含多个区段，而且每个区段包含一个或多个步骤。有关更多信息，请参阅 [查询处理](c-query-processing.md)。
STL\$1SAVE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1SAVE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SAVE.html)
## 示例查询
以下查询显示最近查询中在每个切片上执行的保存步骤。
```
select query, slice, segment, step, tasknum, rows, tbl
from stl_save where query = pg_last_query_id();
query | slice | segment | step | tasknum | rows | tbl
-------+-------+---------+------+---------+------+-----
52236 | 3 | 0 | 2 | 21 | 0 | 239
52236 | 2 | 0 | 2 | 20 | 0 | 239
52236 | 2 | 2 | 2 | 20 | 0 | 239
52236 | 3 | 2 | 2 | 21 | 0 | 239
52236 | 1 | 0 | 2 | 21 | 0 | 239
52236 | 0 | 0 | 2 | 20 | 0 | 239
52236 | 0 | 2 | 2 | 20 | 0 | 239
52236 | 1 | 2 | 2 | 21 | 0 | 239
(8 rows)
```
# STL\$1SCAN
分析查询的表扫描步骤。此表中行的步骤数始终为 0，因为扫描是分段中的第一步。
STL\$1SCAN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1SCAN 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SCAN.html)
## 扫描类型
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SCAN.html)
## 使用说明
理想情况下，`rows` 应相对接近于 `rows_pre_filter`。`rows` 与 `rows_pre_filter` 之间的一个很大的区别是，它意味着执行引擎将要扫描稍后将被丢弃的行（这样做的效率较低）。`rows_pre_filter` 与 `rows_pre_user_filter` 之间的区别是扫描中虚影行的数量。运行 VACUUM 可移除标记为删除的行。`rows` 与 `rows_pre_user_filter` 之间的区别是查询筛选的行的数量。如果用户筛选器丢弃了大量行，则查看您选择的排序列，或者，如果这是由于大量未排序的区域造成的，请运行 vacuum。
## 示例查询
以下示例显示 `rows_pre_filter` 大于 `rows_pre_user_filter`，因为该表已删除尚未真空化的行（虚影行）。
```
SELECT query, slice, segment,step,rows, rows_pre_filter, rows_pre_user_filter
from stl_scan where query = pg_last_query_id();
query | slice | segment | step | rows | rows_pre_filter | rows_pre_user_filter
-------+--------+---------+------+-------+-----------------+----------------------
42915 | 0 | 0 | 0 | 43159 | 86318 | 43159
42915 | 0 | 1 | 0 | 1 | 0 | 0
42915 | 1 | 0 | 0 | 43091 | 86182 | 43091
42915 | 1 | 1 | 0 | 1 | 0 | 0
42915 | 2 | 0 | 0 | 42778 | 85556 | 42778
42915 | 2 | 1 | 0 | 1 | 0 | 0
42915 | 3 | 0 | 0 | 43428 | 86856 | 43428
42915 | 3 | 1 | 0 | 1 | 0 | 0
42915 | 10000 | 2 | 0 | 4 | 0 | 0
(9 rows)
```
# STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS
记录超出 schema 配额时的匹配项、时间戳、XID 和其他有用信息。
STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SCHEMA_QUOTA_VIOLATIONS.html)
## 示例查询
以下查询显示配额冲突的结果：
```
SELECT userid, TRIM(SCHEMA_NAME) "schema_name", quota, disk_usage, disk_usage_pct, timestamp FROM
stl_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC;
```
此查询返回指定 schema 的以下示例输出：
```
userid | schema_name | quota | disk_usage | disk_usage_pct |timestamp
-------+--------------+-------+------------+----------------+----------------------------
104 | sales_schema | 2048 | 2798 | 136.62 | 2020-04-20 20:09:25.494723
(1 row)
```
# STL\$1SESSIONS
返回有关用户会话历史记录的信息。
STL\$1SESSIONS 与 STV\$1SESSIONS 的不同之处在于，STL\$1SESSIONS 包含会话历史记录，而 STV\$1SESSIONS 包含当前活动会话。
STL\$1SESSIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SESSIONS.html)
## 示例查询
要查看 TICKIT 数据库的会话历史记录，请键入以下查询：
```
select starttime, process, user_name, timeout_sec, timed_out
from stl_sessions
where db_name='tickit' order by starttime;
```
此查询返回以下示例输出：
```
starttime | process | user_name | timeout_sec | timed_out
---------------------------+---------+------------------------+-------------+-------------
2008-09-15 09:54:06.746705 | 32358 | dwuser | 120 | 1
2008-09-15 09:56:34.30275 | 32744 | dwuser | 60 | 1
2008-09-15 11:20:34.694837 | 14906 | dwuser | 0 | 0
2008-09-15 11:22:16.749818 | 15148 | dwuser | 0 | 0
2008-09-15 14:32:44.66112 | 14031 | dwuser | 0 | 0
2008-09-15 14:56:30.22161 | 18380 | dwuser | 0 | 0
2008-09-15 15:28:32.509354 | 24344 | dwuser | 0 | 0
2008-09-15 16:01:00.557326 | 30153 | dwuser | 120 | 1
2008-09-15 17:28:21.419858 | 12805 | dwuser | 0 | 0
2008-09-15 20:58:37.601937 | 14951 | dwuser | 60 | 1
2008-09-16 11:12:30.960564 | 27437 | dwuser | 60 | 1
2008-09-16 14:11:37.639092 | 23790 | dwuser | 3600 | 1
2008-09-16 15:13:46.02195 | 1355 | dwuser | 120 | 1
2008-09-16 15:22:36.515106 | 2878 | dwuser | 120 | 1
2008-09-16 15:44:39.194579 | 6470 | dwuser | 120 | 1
2008-09-16 16:50:27.02138 | 17254 | dwuser | 120 | 1
2008-09-17 12:05:02.157208 | 8439 | dwuser | 3600 | 0
(17 rows)
```
# STL\$1SORT
显示查询的排序执行步骤，如使用 ORDER BY 处理的步骤。
STL\$1SORT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1SORT 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SORT.html)
## 示例查询
以下示例返回切片 0 和分段 1 的排序结果。
```
select query, bytes, tbl, is_diskbased, workmem
from stl_sort
where slice=0 and segment=1;
```
```
query | bytes | tbl | is_diskbased | workmem
-------+---------+-----+--------------+-----------
567 | 3126968 | 241 | f | 383385600
604 | 5292 | 242 | f | 383385600
675 | 104776 | 251 | f | 383385600
525 | 3126968 | 251 | f | 383385600
585 | 5068 | 241 | f | 383385600
630 | 204808 | 266 | f | 383385600
704 | 0 | 242 | f | 0
669 | 4606416 | 241 | f | 383385600
696 | 104776 | 241 | f | 383385600
651 | 4606416 | 254 | f | 383385600
632 | 0 | 256 | f | 0
599 | 396 | 241 | f | 383385600
86397 | 0 | 242 | f | 0
621 | 5292 | 241 | f | 383385600
86325 | 0 | 242 | f | 0
572 | 5068 | 242 | f | 383385600
645 | 204808 | 241 | f | 383385600
590 | 396 | 242 | f | 383385600
(18 rows)
```
# STL\$1SSHCLIENT\$1ERROR
记录由 SSH 客户端发现的所有错误。
STL\$1SSHCLIENT\$1ERROR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_SSHCLIENT_ERROR.html)
# STL\$1STREAM\$1SEGS
列出流与并发分段之间的关系。
在这种情况下，流是 Amazon Redshift 流。此系统视图不适用于[流式摄取到实体化视图](materialized-view-streaming-ingestion.md)。
STL\$1STREAM\$1SEGS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1STREAM\$1SEGS 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_STREAM_SEGS.html)
## 示例查询
要查看最近查询的流与并发分段之间的关系，请键入以下查询：
```
select *
from stl_stream_segs
where query = pg_last_query_id();
query | stream | segment
-------+--------+---------
10 | 1 | 2
10 | 0 | 0
10 | 2 | 4
10 | 1 | 3
10 | 0 | 1
(5 rows)
```
# STL\$1TR\$1CONFLICT
显示用于确定并解决与数据库表的事务冲突的信息。
当两个或更多用户正在查询和修改表中的数据行（以使其事务无法序列化）时，会发生事务冲突。如果事务运行一个将会破坏可序列性的语句，将会被停止并回滚。每次发生事务冲突时，Amazon Redshift 都会在包含有关被取消事务详细信息的 STL\$1TR\$1CONFLICT 系统表中写入数据行。有关更多信息，请参阅 [Amazon Redshift 中的隔离级别](c_serial_isolation.md)。
STL\$1TR\$1CONFLICT 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_TR_CONFLICT.html)
## 示例查询
要返回有关涉及某一特定表的冲突的信息，请运行指定了表 ID 的查询：
```
select * from stl_tr_conflict where table_id=100234
order by xact_start_ts;
xact_id|process_| xact_start_ts | abort_time |table_
|id | | |id
-------+--------+--------------------------+--------------------------+------
1876 | 8551 |2010-03-30 09:19:15.852326|2010-03-30 09:20:17.582499|100234
1928 | 15034 |2010-03-30 13:20:00.636045|2010-03-30 13:20:47.766817|100234
1991 | 23753 |2010-04-01 13:05:01.220059|2010-04-01 13:06:06.94098 |100234
2002 | 23679 |2010-04-01 13:17:05.173473|2010-04-01 13:18:27.898655|100234
(4 rows)
```
您可以从针对可串行性冲突的错误消息的 DETAIL 部分中获取表 ID（错误 1023）。
# STL\$1UNDONE
显示有关已撤消的事务的信息。
STL\$1UNDONE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_UNDONE.html)
## 示例查询
要查看所有已撤消事务的简明日志，请键入以下命令：
```
select xact_id, xact_id_undone, table_id from stl_undone;
```
此命令返回以下示例输出：
```
xact_id | xact_id_undone | table_id
---------+----------------+----------
1344 | 1344 | 100192
1326 | 1326 | 100192
1551 | 1551 | 100192
(3 rows)
```
# STL\$1UNIQUE
分析在 SELECT 列表中使用 DISTINCT 函数时或者在 UNION 或 INTERSECT 查询中删除重复项时发生的执行步骤。
STL\$1UNIQUE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1UNIQUE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_UNIQUE.html)
## 示例查询
假设您运行以下查询：
```
select distinct eventname
from event order by 1;
```
假定上个查询的 ID 是 6313，以下示例显示由分段 0 和 1 中每个切片的唯一步骤生成的行的数量。
```
select query, slice, segment, step, datediff(msec, starttime, endtime) as msec, tasknum, rows
from stl_unique where query = 6313
order by query desc, slice, segment, step;
```
```
query | slice | segment | step | msec | tasknum | rows
-------+-------+---------+------+------+---------+------
6313 | 0 | 0 | 2 | 0 | 22 | 550
6313 | 0 | 1 | 1 | 256 | 20 | 145
6313 | 1 | 0 | 2 | 1 | 23 | 540
6313 | 1 | 1 | 1 | 42 | 21 | 127
6313 | 2 | 0 | 2 | 1 | 22 | 540
6313 | 2 | 1 | 1 | 255 | 20 | 158
6313 | 3 | 0 | 2 | 1 | 23 | 542
6313 | 3 | 1 | 1 | 38 | 21 | 146
(8 rows)
```
# STL\$1UNLOAD\$1LOG
记录卸载操作的详细信息。
STL\$1UNLOAD\$1LOG 为由 UNLOAD 语句创建的每个文件记录一行。例如，如果 UNLOAD 创建 12 个文件，则 STL\$1UNLOAD\$1LOG 将包含 12 个对应的行。
STL\$1UNLOAD\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1UNLOAD\$1LOG 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md) 和 [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_UNLOAD_LOG.html)
## 示例查询
要获得已由 UNLOAD 命令写入到 Amazon S3 的文件的列表，您可以在 UNLOAD 完成后调用 Amazon S3 列表操作。您还可以查询 STL\$1UNLOAD\$1LOG。
以下查询返回上次完成的查询的 UNLOAD 创建的文件的路径名：
```
select query, substring(path,0,40) as path
from stl_unload_log
where query = pg_last_query_id()
order by path;
```
此命令返回以下示例输出：
```
query | path
-------+--------------------------------------
2320 | s3://amzn-s3-demo-bucket/venue0000_part_00
2320 | s3://amzn-s3-demo-bucket/venue0001_part_00
2320 | s3://amzn-s3-demo-bucket/venue0002_part_00
2320 | s3://amzn-s3-demo-bucket/venue0003_part_00
(4 rows)
```
# STL\$1USAGE\$1CONTROL
STL\$1USAGE\$1CONTROL 视图包含在达到使用限制时记录的信息。有关使用限制的更多信息，请参阅《Amazon Redshift 管理指南》**中的[管理使用限制](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-usage-limits.html)。
STL\$1USAGE\$1CONTROL 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_USAGE_CONTROL.html)
## 示例查询
以下 SQL 示例返回达到使用限制时记录的部分信息。
```
select query, pid, eventtime, feature_type
from stl_usage_control
order by eventtime desc
limit 5;
```
# STL\$1USERLOG
记录数据库用户的以下更改的详细信息。
+ 创建用户
+ 删除用户
+ 更改用户（重命名）
+ 更改用户（更改属性）
STL\$1USERLOG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1USERLOG](SYS_USERLOG.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_USERLOG.html)
## 示例查询
以下示例执行四种用户操作，然后查询 STL\$1USERLOG 视图。
```
create user userlog1 password 'Userlog1';
alter user userlog1 createdb createuser;
alter user userlog1 rename to userlog2;
drop user userlog2;
select userid, username, oldusername, action, usecreatedb, usesuper from stl_userlog order by recordtime desc;
```
```
userid | username | oldusername | action | usecreatedb | usesuper
--------+-----------+-------------+---------+-------------+----------
108 | userlog2 | | drop | 1 | 1
108 | userlog2 | userlog1 | rename | 1 | 1
108 | userlog1 | | alter | 1 | 1
108 | userlog1 | | create | 0 | 0
(4 rows)
```
# STL\$1UTILITYTEXT
捕获在数据库上运行的非 SELECT SQL 命令的文本。
查询 STL\$1UTILITYTEXT 视图以捕获在系统上运行的 SQL 语句的下列子集：
+ ABORT、BEGIN、COMMIT、END、ROLLBACK
+ ANALYZE
+ CALL
+ CANCEL
+ COMMENT
+ CREATE、ALTER、DROP DATABASE
+ CREATE、ALTER、DROP USER
+ EXPLAIN
+ GRANT、REVOKE
+ LOCK
+ RESET
+ SET
+ SHOW
+ TRUNCATE
另请参阅 [STL\$1DDLTEXT](r_STL_DDLTEXT.md)、[STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) 和 [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)。
使用 STARTTIME 和 ENDTIME 列了解在某个给定时间段内记录了哪些语句。SQL 文本的长数据块已分为 200 个字符长的行；SEQUENCE 列标识了属于一个语句的文本片段。
STL\$1UTILITYTEXT 系统表同时支持实体化视图的 MANUAL 和 AUTO REFRESH 操作。要在实体化视图上识别 AUTO REFRESH，请找到 `label` 列。所有 AUTO REFRESH 查询都有一个值为 `maintenance` 的标签。
STL\$1UTILITYTEXT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_UTILITYTEXT.html)
## 示例查询
以下查询返回 2012 年 1 月 26 日运行的“utility”命令的文本。在这种情况下，运行的是一些 SET 命令和一个 SHOW ALL 命令：
```
select starttime, sequence, rtrim(text)
from stl_utilitytext
where starttime like '2012-01-26%'
order by starttime, sequence;
starttime | sequence | rtrim
---------------------------+-----+----------------------------------
2012-01-26 13:05:52.529235 | 0 | show all;
2012-01-26 13:20:31.660255 | 0 | SET query_group to ''
2012-01-26 13:20:54.956131 | 0 | SET query_group to 'soldunsold.sql'
...
```
### 重新构造存储的 SQL
要重新构造存储在 STL\$1UTILITYTEXT 的 `text` 列中的 SQL，请运行 SELECT 语句，以从 `text` 列中的一个或多个部分创建 SQL。在运行重新构造的 SQL 之前，将任何 (`\n`) 特殊字符替换为新行。以下 SELECT 语句的结果是 `query_statement` 字段中重新构造的 SQL 的行。
```
SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement
FROM stl_utilitytext GROUP BY xid order by xid;
```
例如，以下查询将 query\$1group 设置为零的字符串。查询本身超过 200 个字符，并存储在 STL\$1UTILITYTEXT 中的几个部分内。
```
set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000';
```
在此示例中，查询存储在 STL\$1UTILITYTEXT 的 `text` 列的 2 个部分（行）中。
```
select query, sequence, text
from stl_utilitytext where query=pg_last_query_id() order by query desc, sequence limit 10;
```
```
starttime | sequence | text
----------------------------+----------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
2019-07-23 22:55:34.926198 | 0 | set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000
2019-07-23 22:55:34.926198 | 1 | 000000';
```
要重新构造存储在 STL\$1UTILITYTEXT 中的 SQL，请运行以下 SQL。
```
select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS query_statement
from stl_utilitytext where query=pg_last_query_id();
```
要在客户端中使用生成的重新构造的 SQL，需将任何 (`\n`) 特殊字符替换为新行。
```
query_statement
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000';
```
# STL\$1VACUUM
显示已真空化的表的行和数据块统计数据。
该视图显示了特定于每个 vacuum 操作开始和完成时的信息，并演示了运行此操作的好处。有关运行该命令的要求的信息，请参阅 [VACUUM](r_VACUUM_command.md) 命令描述。
STL\$1VACUUM 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_VACUUM.html)
## 示例查询
以下查询报告表 108313 的 vacuum 统计数据。此表在一系列插入和删除后已执行 vacuum 操作。
```
select xid, table_id, status, rows, sortedrows, blocks, eventtime,
reclaimable_rows, reclaimable_space_mb
from stl_vacuum where table_id=108313 order by eventtime;
xid | table_id | status | rows | sortedrows | blocks | eventtime | reclaimable_rows | reclaimable_space_mb
-------+----------+-------------------------+------+------------+--------+----------------------+------------------+----------------------
14294 | 108313 | Started | 1950 | 408 | 28 | 2016-05-19 17:36:01 | 984 | 17
14294 | 108313 | Finished | 966 | 966 | 11 | 2016-05-19 18:26:13 | 0 | 0
15126 | 108313 | Skipped(sorted>=95%) | 966 | 966 | 11 | 2016-05-19 18:26:38 | 0 | 0
```
在 VACUUM 启动时，表包含了存储在 28 个 1MB 数据块中的 1,950 行。Amazon Redshift 估计，它可以通过 vacuum 操作回收 984 行或 17 个数据块的磁盘空间。
在状态为“完成”的行中，ROWS 列显示值 966，而 BLOCKS 列值为 11，低于 28。vacuum 回收了估计的磁盘空间量，在 vacuum 操作完成后，没有剩余可回收的行或空间。
在排序阶段（事务 15126），vacuum 无法跳过此表，因为行是按排序键顺序插入的。
以下示例显示在大型 INSERT 操作之后，针对 SALES 表（在此示例中为表 110116）的 SORT ONLY vacuum 操作的统计数据：
```
vacuum sort only sales;
select xid, table_id, status, rows, sortedrows, blocks, eventtime
from stl_vacuum order by xid, table_id, eventtime;
xid |table_id| status | rows |sortedrows|blocks| eventtime
----+--------+-----------------+-------+----------+------+--------------------
...
2925| 110116 |Started Sort Only|1379648| 172456 | 132 | 2011-02-24 16:25:21...
2925| 110116 |Finished |1379648| 1379648 | 132 | 2011-02-24 16:26:28...
```
# STL\$1WINDOW
分析执行窗口函数的查询步骤。
STL\$1WINDOW 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STL\$1WINDOW 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_WINDOW.html)
## 示例查询
以下示例返回切片 0 和分段 3 的窗口函数结果。
```
select query, tasknum, rows, is_diskbased, workmem
from stl_window
where slice=0 and segment=3;
```
```
query | tasknum | rows | is_diskbased | workmem
-------+---------+------+--------------+----------
86326 | 36 | 1857 | f | 95256616
705 | 15 | 1857 | f | 95256616
86399 | 27 | 1857 | f | 95256616
649 | 10 | 0 | f | 95256616
(4 rows)
```
# STL\$1WLM\$1ERROR
随时记录发生的任何与 WLM 相关的错误。
STL\$1WLM\$1ERROR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_WLM_ERROR.html)
# STL\$1WLM\$1RULE\$1ACTION
记录有关从 WLM 查询监控规则生成的与用户定义的队列关联的操作的详细信息。有关更多信息，请参阅 [WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。
STL\$1WLM\$1RULE\$1ACTION 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_WLM_RULE_ACTION.html)
## 示例查询
以下示例查找由查询监控规则停止的查询。
```
Select query, rule
from stl_wlm_rule_action
where action = 'abort'
order by query;
```
# STL\$1WLM\$1QUERY
包含在由 WLM 处理的服务类中每次尝试执行查询的记录。
STL\$1WLM\$1QUERY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STL_WLM_QUERY.html)
## 示例查询
**查看在队列中等待和执行的平均查询时间**
以下查询显示 4 以上的服务类的当前配置。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
以下查询返回针对每个服务类的每个查询在查询队列和执行过程中消耗的平均时间（单位为微秒）。
```
select service_class as svc_class, count(*),
avg(datediff(microseconds, queue_start_time, queue_end_time)) as avg_queue_time,
avg(datediff(microseconds, exec_start_time, exec_end_time )) as avg_exec_time
from stl_wlm_query
where service_class > 4
group by service_class
order by service_class;
```
此查询返回以下示例输出：
```
svc_class | count | avg_queue_time | avg_exec_time
-----------+-------+----------------+---------------
5 | 20103 | 0 | 80415
5 | 3421 | 34015 | 234015
6 | 42 | 0 | 944266
7 | 196 | 6439 | 1364399
(4 rows)
```
**查看在队列中等待和执行的最大查询时间**
以下查询返回针对每个服务类的每个查询在任何查询队列和执行过程中消耗的总时间量（单位为微秒）。
```
select service_class as svc_class, count(*),
max(datediff(microseconds, queue_start_time, queue_end_time)) as max_queue_time,
max(datediff(microseconds, exec_start_time, exec_end_time )) as max_exec_time
from stl_wlm_query
where svc_class > 5
group by service_class
order by service_class;
```
```
svc_class | count | max_queue_time | max_exec_time
-----------+-------+----------------+---------------
6 | 42 | 0 | 3775896
7 | 197 | 37947 | 16379473
(4 rows)
```
# 快照数据的 STV 表
STV 表是虚拟系统表，包含当前系统数据的快照。
**Topics**
+ [STV\$1ACTIVE\$1CURSORS](r_STV_ACTIVE_CURSORS.md)
+ [STV\$1BLOCKLIST](r_STV_BLOCKLIST.md)
+ [STV\$1CURSOR\$1CONFIGURATION](r_STV_CURSOR_CONFIGURATION.md)
+ [STV\$1DB\$1ISOLATION\$1LEVEL](r_STV_DB_ISOLATION_LEVEL.md)
+ [STV\$1EXEC\$1STATE](r_STV_EXEC_STATE.md)
+ [STV\$1INFLIGHT](r_STV_INFLIGHT.md)
+ [STV\$1LOAD\$1STATE](r_STV_LOAD_STATE.md)
+ [STV\$1LOCKS](r_STV_LOCKS.md)
+ [STV\$1ML\$1MODEL\$1INFO](r_STV_ML_MODEL_INFO.md)
+ [STV\$1MV\$1DEPS](r_STV_MV_DEPS.md)
+ [STV\$1MV\$1INFO](r_STV_MV_INFO.md)
+ [STV\$1NODE\$1STORAGE\$1CAPACITY](r_STV_NODE_STORAGE_CAPACITY.md)
+ [STV\$1PARTITIONS](r_STV_PARTITIONS.md)
+ [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md)
+ [STV\$1RECENTS](r_STV_RECENTS.md)
+ [STV\$1SESSIONS](r_STV_SESSIONS.md)
+ [STV\$1SLICES](r_STV_SLICES.md)
+ [STV\$1STARTUP\$1RECOVERY\$1STATE](r_STV_STARTUP_RECOVERY_STATE.md)
+ [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)
+ [STV\$1TBL\$1TRANS](r_STV_TBL_TRANS.md)
+ [STV\$1WLM\$1CLASSIFICATION\$1CONFIG](r_STV_WLM_CLASSIFICATION_CONFIG.md)
+ [STV\$1WLM\$1QMR\$1CONFIG](r_STV_WLM_QMR_CONFIG.md)
+ [STV\$1WLM\$1QUERY\$1QUEUE\$1STATE](r_STV_WLM_QUERY_QUEUE_STATE.md)
+ [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md)
+ [STV\$1WLM\$1QUERY\$1TASK\$1STATE](r_STV_WLM_QUERY_TASK_STATE.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG](r_STV_WLM_SERVICE_CLASS_CONFIG.md)
+ [STV\$1WLM\$1SERVICE\$1CLASS\$1STATE](r_STV_WLM_SERVICE_CLASS_STATE.md)
+ [STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE](r_STV_XRESTORE_ALTER_QUEUE_STATE.md)
# STV\$1ACTIVE\$1CURSORS
STV\$1ACTIVE\$1CURSORS 显示当前打开的光标的详细信息。有关更多信息，请参阅 [DECLARE](declare.md)。
STV\$1ACTIVE\$1CURSORS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。用户只能查看自己打开的光标。超级用户可以查看所有光标。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_ACTIVE_CURSORS.html)
# STV\$1BLOCKLIST
STV\$1BLOCKLIST 包含数据库中每个分片、表或列所使用的 1 MB 磁盘块的数目。
将聚合查询与 STV\$1BLOCKLIST 结合使用（如以下示例所示）可确定为每个数据库、表、分片或列分配的 1 MB 磁盘块的数目。您还可以使用 [STV\$1PARTITIONS](r_STV_PARTITIONS.md) 查看有关磁盘利用率的摘要信息。
STV\$1BLOCKLIST 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
STV\$1BLOCKLIST 仅记录由预置集群或无服务器命名空间拥有的块。如果数据库包含从数据共享创建者共享的块，则这些块不会包含在 STV\$1BLOCKLIST 中。有关数据共享的更多信息，请转至[Amazon Redshift 中的数据共享](datashare-overview.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_BLOCKLIST.html)
## 示例查询
分配的每个磁盘块在 STV\$1BLOCKLIST 中对应一行，因此选择所有行的查询可能会返回非常多的行。建议仅将聚合查询与 STV\$1BLOCKLIST 结合使用。
[SVV\$1DISKUSAGE](r_SVV_DISKUSAGE.md) 视图以对用户更友好的格式提供相似信息；而以下示例演示 STV\$1BLOCKLIST 表的一个用例。
要确定 VENUE 表中每一列所使用的 1 MB 块数，请键入以下查询：
```
select col, count(*)
from stv_blocklist, stv_tbl_perm
where stv_blocklist.tbl = stv_tbl_perm.id
and stv_blocklist.slice = stv_tbl_perm.slice
and stv_tbl_perm.name = 'venue'
group by col
order by col;
```
此查询返回分配到 VENUE 表中每一列的 1 MB 块的数目，如以下示例数据所示：
```
col | count
-----+-------
0 | 4
1 | 4
2 | 4
3 | 4
4 | 4
5 | 4
7 | 4
8 | 4
(8 rows)
```
以下查询显示表数据是否实际分布于所有分片间：
```
select trim(name) as table, stv_blocklist.slice, stv_tbl_perm.rows
from stv_blocklist,stv_tbl_perm
where stv_blocklist.tbl=stv_tbl_perm.id
and stv_tbl_perm.slice=stv_blocklist.slice
and stv_blocklist.id > 10000 and name not like '%#m%'
and name not like 'systable%'
group by name, stv_blocklist.slice, stv_tbl_perm.rows
order by 3 desc;
```
此查询生成以下示例输出，其中显示行数最多的表的平均数据分布：
```
table | slice | rows
----------+-------+-------
listing | 13 | 10527
listing | 14 | 10526
listing | 8 | 10526
listing | 9 | 10526
listing | 7 | 10525
listing | 4 | 10525
listing | 17 | 10525
listing | 11 | 10525
listing | 5 | 10525
listing | 18 | 10525
listing | 12 | 10525
listing | 3 | 10525
listing | 10 | 10525
listing | 2 | 10524
listing | 15 | 10524
listing | 16 | 10524
listing | 6 | 10524
listing | 19 | 10524
listing | 1 | 10523
listing | 0 | 10521
...
(180 rows)
```
以下查询确定是否向磁盘提交了任何已逻辑删除的块：
```
select slice, col, tbl, blocknum, newblock
from stv_blocklist
where tombstone > 0;
slice | col | tbl | blocknum | newblock
-------+-----+--------+----------+----------
4 | 0 | 101285 | 0 | 1
4 | 2 | 101285 | 0 | 1
4 | 4 | 101285 | 1 | 1
5 | 2 | 101285 | 0 | 1
5 | 0 | 101285 | 0 | 1
5 | 1 | 101285 | 0 | 1
5 | 4 | 101285 | 1 | 1
...
(24 rows)
```
# STV\$1CURSOR\$1CONFIGURATION
STV\$1CURSOR\$1CONFIGURATION 显示光标配置约束。有关更多信息，请参阅 [游标约束](declare.md#declare-constraints)。
STV\$1CURSOR\$1CONFIGURATION 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_CURSOR_CONFIGURATION.html)
# STV\$1DB\$1ISOLATION\$1LEVEL
STV\$1DB\$1ISOLATION\$1LEVEL 显示数据库的当前隔离级别。有关隔离级别的更多信息，请参阅 [Amazon Redshift 中的隔离级别](c_serial_isolation.md)。
STV\$1DB\$1ISOLATION\$1LEVEL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_DB_ISOLATION_LEVEL.html)
# STV\$1EXEC\$1STATE
使用 STV\$1EXEC\$1STATE 表可查看有关正在计算节点上主动运行的查询和查询步骤的信息。
此信息通常仅用于排查工程问题。视图 SVV\$1QUERY\$1STATE 和 SVL\$1QUERY\$1SUMMARY 从 STV\$1EXEC\$1STATE 提取其信息。
STV\$1EXEC\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_EXEC_STATE.html)
## 示例查询
Amazon Redshift 建议查询 SVL\$1QUERY\$1SUMMARY 或 SVV\$1QUERY\$1STATE 以对用户更友好的格式获取 STV\$1EXEC\$1STATE 中的信息，而不是直接查询 STV\$1EXEC\$1STATE。有关更多详细信息，请参阅 [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md) 或 [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md) 表文档。
# STV\$1INFLIGHT
使用 STV\$1INFLIGHT 表可确定当前正在对集群运行的查询。如果您正在进行故障排除，这有助于检查长时间运行的查询的状态。
STV\$1INFLIGHT 不会显示仅领导节点查询。有关更多信息，请参阅 [仅领导节点函数](c_SQL_functions_leader_node_only.md)。STV\$1INFLIGHT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 使用 STV\$1INFLIGHT 进行故障排除
如果您使用 STV\$1INFLIGHT 对一个查询或一组查询的性能进行故障排除，请注意以下几点：
+ 长时间运行的未结事务通常会增加负载。这些未结事务可能会导致其他查询的运行时间更长。
+ 如果长时间运行的 COPY 和 ETL 任务占用了大量计算资源，则可能会影响集群上运行的其他查询。在大多数情况下，将这些长时间运行的任务移至使用率较低的时间，可以提高报告或分析工作负载的性能。
+ 有些视图为 STV\$1INFLIGHT 提供了相关信息。其中包括 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)（用于捕获 SQL 命令的查询文本）和 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)（用于将 STV\$1INFLIGHT 联接到 STL\$1QUERYTEXT）。您也可以将 [STV\$1RECENTS](r_STV_RECENTS.md) 与 STV\$1INFLIGHT 结合使用来进行故障排除。例如，STV\$1RECENTS 可以指示特定查询是处于*正在运行* 还是*已完成* 状态。将这些信息与来自 STV\$1INFLIGHT 的结果相结合，可以为您提供有关查询的属性和计算资源影响的更多信息。
您还可以使用 Amazon Redshift 控制台监控正在运行的查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_INFLIGHT.html)
## 示例查询
要查看当前正在对数据库运行的所有活动查询，请键入以下查询：
```
select * from stv_inflight;
```
下面的示例输出显示当前正在运行两个查询，其中包括 STV\$1INFLIGHT 查询自身和已从名为 `avgwait.sql` 的脚本运行的查询：
```
select slice, query, trim(label) querylabel, pid,
starttime, substring(text,1,20) querytext
from stv_inflight;
slice|query|querylabel | pid | starttime | querytext
-----+-----+-----------+-----+--------------------------+--------------------
1011 | 21 | | 646 |2012-01-26 13:23:15.645503|select slice, query,
1011 | 20 |avgwait.sql| 499 |2012-01-26 13:23:14.159912|select avg(datediff(
(2 rows)
```
以下查询选择了几列，包括 concurrency\$1scaling\$1status。此列表示是否正在向并发扩展集群发送查询。如果对于某些结果，该值为 `1`，则表明正在使用并发扩展计算资源。有关更多信息，请参阅 [并发扩展](concurrency-scaling.md)。
```
select userid,
query,
pid,
starttime,
text,
suspended,
concurrency_scaling_status
from STV_INFLIGHT;
```
示例输出显示了正在将一个查询发送到并发扩展集群。
```
query | pid | starttime | text | suspended | concurrency_scaling_status
--------+---------+----------------------------|------------------------|---------------|-------------------------------
1234567 | 123456 | 2012-01-26 13:23:15.645503 | select userid, query... 0 1
2345678 | 234567 | 2012-01-26 13:23:14.159912 | select avg(datediff(... 0 0
(2 rows)
```
有关排除查询性能故障的更多提示，请参阅[查询故障排除](queries-troubleshooting.md)。
# STV\$1LOAD\$1STATE
使用 STV\$1LOAD\$1STATE 表可以查找有关正在进行的 COPY 语句当前状态的信息。
每加载百万条记录后，COPY 命令就会更新此表。
STV\$1LOAD\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_LOAD_STATE.html)
## 示例查询
要查看 COPY 命令的每个分片进度，请键入以下查询。此示例使用 PG\$1LAST\$1COPY\$1ID() 函数检索最后一条 COPY 命令的信息。
```
select slice , bytes_loaded, bytes_to_load , pct_complete from stv_load_state where query = pg_last_copy_id();
slice | bytes_loaded | bytes_to_load | pct_complete
-------+--------------+---------------+--------------
2 | 0 | 0 | 0
3 | 12840898 | 39104640 | 32
(2 rows)
```
# STV\$1LOCKS
使用 STV\$1LOCKS 表可以查看数据库中各个表的所有当前更新。
Amazon Redshift 锁定表以防止两个用户同时更新同一个表。STV\$1LOCKS 表显示所有当前表更新，而查询 [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md) 表则可查看锁定冲突的日志。使用 [SVV\$1TRANSACTIONS](r_SVV_TRANSACTIONS.md) 视图可标识未结事务和锁定争用问题。
STV\$1LOCKS 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_LOCKS.html)
## 示例查询
要查看当前事务中发生的所有锁定，请键入以下命令：
```
select table_id, last_update, lock_owner, lock_owner_pid from stv_locks;
```
此查询返回以下示例输出，其中显示三个当前生效的锁定：
```
table_id | last_update | lock_owner | lock_owner_pid
----------+----------------------------+------------+----------------
100004 | 2008-12-23 10:08:48.882319 | 1043 | 5656
100003 | 2008-12-23 10:08:48.779543 | 1043 | 5656
100140 | 2008-12-23 10:08:48.021576 | 1043 | 5656
(3 rows)
```
# STV\$1ML\$1MODEL\$1INFO
有关机器学习模型当前状态的状态信息。
STV\$1ML\$1MODEL\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_ML_MODEL_INFO.html)
## 示例查询
以下查询显示机器学习模型的当前状态。
```
SELECT schema_name, model_name, model_state
FROM stv_ml_model_info;
schema_name | model_name | model_state
-------------+------------------------------+--------------------------------------
public | customer_churn_auto_model | Train Model On SageMaker In Progress
public | customer_churn_xgboost_model | Model is Ready
(2 row)
```
# STV\$1MV\$1DEPS
STV\$1MV\$1DEPS 表显示了具体化视图与 Amazon Redshift 内其他具体化视图的依赖关系。
有关具体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
STV\$1MV\$1DEPS 对所有用户可见。超级用户可以查看所有行；常规用户只能列出驻留在他们有权访问的架构中的实体化视图。有关更多信息，请参阅[系统表和视图中的数据可见性](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_MV_DEPS.html)
## 示例查询
以下查询返回一个输出行，该行指示具体化视图 `mv_over_foo` 在其定义中使用具体化视图 `mv_foo` 作为二依赖项。
```
CREATE SCHEMA test_ivm_setup;
CREATE TABLE test_ivm_setup.foo(a INT);
CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo;
CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo;
SELECT * FROM stv_mv_deps;
db_name | schema | name | ref_schema | ref_name | ref_database_name
---------+-----------------+-------------+----------------+----------+------------------
dev | test_ivm_setup | mv_over_foo | test_ivm_setup | mv_foo | dev
```
# STV\$1MV\$1INFO
STV\$1MV\$1INFO 表对于每个具体化视图、数据是否陈旧以及状态信息包含一行。
有关具体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
STV\$1MV\$1INFO 对所有用户可见。超级用户可以查看所有行；常规用户只能列出驻留在他们有权访问的架构中的实体化视图。有关更多信息，请参阅[系统表和视图中的数据可见性](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_MV_INFO.html)
## 示例查询
要查看所有实体化视图的状态，请运行以下查询。
```
select * from stv_mv_info;
```
此查询返回以下示例输出。
```
db_name | schema | name | updated_upto_xid | is_stale | owner_user_name | state | autorefresh | autorewrite
---------+--------------------+---------+------------------+----------+-----------------+-------+-------------+------------
dev | test_ivm_setup | mv | 1031 | f | catch-22 | 1 | 1 | 0
dev | test_ivm_setup | old_mv | 988 | t | lotr | 1 | 0 | 1
```
# STV\$1NODE\$1STORAGE\$1CAPACITY
STV\$1NODE\$1STORAGE\$1CAPACITY 表显示了集群中每个节点的总存储容量和总已用容量的详细信息。它为每个节点包含一行。
STV\$1NODE\$1STORAGE\$1CAPACITY 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_NODE_STORAGE_CAPACITY.html)
## 示例查询
**注意**
以下示例的结果因集群的节点规范而异。将列 `capacity` 添加到 SQL SELECT 以检索集群的容量。
以下查询返回 1 MB 磁盘块中的已用空间和总容量。此示例在双节点 dc2.8xlarge 集群上运行。
```
select node, used from stv_node_storage_capacity order by node;
```
此查询返回以下示例输出。
```
node | used
------+-------
0 | 30597
1 | 27089
```
以下查询返回 1 MB 磁盘块中的已用空间和总容量。此示例在一个双节点 ra3.16xlarge 集群上运行。
```
select node, used from stv_node_storage_capacity order by node;
```
此查询返回以下示例输出。
```
node | used
------+-------
0 | 30591
1 | 27103
```
# STV\$1PARTITIONS
使用 STV\$1PARTITIONS 表可了解 Amazon Redshift 的磁盘速度性能和磁盘利用率。
STV\$1PARTITIONS 中的一行对应每个节点的一个逻辑磁盘卷。
STV\$1PARTITIONS 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_PARTITIONS.html)
## 示例查询
以下查询返回已用磁盘空间和容量（1 MB 磁盘块数），并计算磁盘利用率（占原始磁盘空间的百分比）。原始磁盘空间包括 Amazon Redshift 保留供内部使用的空间，因此它大于名义磁盘容量（可供用户使用的磁盘空间量）。Amazon Redshift 管理控制台的**性能**选项卡上的**已用磁盘空间百分比**指标报告集群使用的名义磁盘容量的百分比。建议您监控 **Percentage of Disk Space Used** 指标以维持集群的名义磁盘容量的使用量。
**重要**
我们强烈建议您不要超过集群的名义磁盘容量。尽管这在某些情况下在技术上可能是可行的，但超过名义磁盘容量会降低集群的容错能力并增加丢失数据的风险。
此示例是在两个节点组成的集群上运行的（每个节点有六个逻辑磁盘分区）。各磁盘的空间使用非常平均，每个磁盘大约使用 25%。
```
select owner, host, diskno, used, capacity,
(used-tossed)/capacity::numeric *100 as pctused
from stv_partitions order by owner;
owner | host | diskno | used | capacity | pctused
-------+------+--------+--------+----------+---------
0 | 0 | 0 | 236480 | 949954 | 24.9
0 | 0 | 1 | 236420 | 949954 | 24.9
0 | 0 | 2 | 236440 | 949954 | 24.9
0 | 1 | 2 | 235150 | 949954 | 24.8
0 | 1 | 1 | 237100 | 949954 | 25.0
0 | 1 | 0 | 237090 | 949954 | 25.0
1 | 1 | 0 | 236310 | 949954 | 24.9
1 | 1 | 1 | 236300 | 949954 | 24.9
1 | 1 | 2 | 236320 | 949954 | 24.9
1 | 0 | 2 | 237910 | 949954 | 25.0
1 | 0 | 1 | 235640 | 949954 | 24.8
1 | 0 | 0 | 235380 | 949954 | 24.8
(12 rows)
```
# STV\$1QUERY\$1METRICS
包含正在用户定义的查询队列中运行的活动查询的指标信息（如处理的行数、CPU 利用率、输入/输出和磁盘利用率）。要查看已完成的查询的指标，请参阅 [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) 系统表。
查询指标按一秒的间隔采样。因此，同一查询的不同运行可能返回稍微不同的时间。此外，运行不到 1 秒的查询段可能不会记录。
STV\$1QUERY\$1METRICS 可跟踪和聚合查询、段和步骤级别的指标。有关查询段和步骤的信息，请参阅[查询计划和执行工作流程](c-query-planning.md)。很多指标（如 `max_rows`、`cpu_time` 等）是跨节点切片进行合计的。有关节点切片的更多信息，请参阅[数据仓库系统架构](c_high_level_system_architecture.md)。
要确定行在哪个级别报告指标，请检查 `segment` 和 `step_type` 列：
+ 如果 `segment` 和 `step_type` 均为 `-1`，则行在查询级别报告指标。
+ 如果 `segment` 不为 `-1`，而 `step_type` 为 `-1`，则行在段级别报告指标。
+ 如果 `segment` 和 `step_type` 均不为 `-1`，则行在步骤级别报告指标。
STV\$1QUERY\$1METRICS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## 步骤类型
下表列出了与数据库用户相关的步骤类型。该表未列出仅供内部使用的步骤类型。如果步骤类型为 -1，则不会在步骤级别报告指标。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## 示例查询
要查找具有较长的 CPU 时间（1000 秒以上）的活动查询，请运行以下查询。
```
select query, cpu_time / 1000000 as cpu_seconds
from stv_query_metrics where segment = -1 and cpu_time > 1000000000
order by cpu_time;
query | cpu_seconds
------+------------
25775 | 9540
```
要查找具有返回超过一百万个行的嵌套循环联接的活动查询，请运行以下查询。
```
select query, rows
from stv_query_metrics
where step_type = 15 and rows > 1000000
order by rows;
query | rows
------+-----------
25775 | 1580225854
```
要查找已运行超过 60 秒且使用的 CPU 时间不到 10 秒的活动查询，请运行以下查询。
```
select query, run_time/1000000 as run_time_seconds
from stv_query_metrics
where segment = -1 and run_time > 60000000 and cpu_time < 10000000;
query | run_time_seconds
------+-----------------
25775 | 114
```
# STV\$1RECENTS
使用 STV\$1RECENTS 表可以了解有关当前活动的和最近运行的数据库查询的信息。
STV\$1RECENTS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 使用 STV\$1RECENTS 进行故障排除
STV\$1RECENTS 对于确定一个查询或一组查询当前是正在运行还是已完成特别有用。它还显示查询运行的持续时间。这有助于了解哪些查询是长时间运行的。
您可以将 STV\$1RECENTS 联接到其他系统视图（例如 [STV\$1INFLIGHT](r_STV_INFLIGHT.md)），以收集有关正在运行的查询的其他元数据。（示例查询部分中有一个示例显示了如何执行此操作。） 您还可以使用从该视图返回的记录以及 Amazon Redshift 控制台中的监控功能来实时排除故障。
对 STV\$1RECENTS 形成补充的系统视图包括 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) 和 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)，前者用于检索 SQL 命令的查询文本，后者用于将 STV\$1INFLIGHT 联接到 STL\$1QUERYTEXT。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_RECENTS.html)
## 示例查询
要确定当前正在对数据库运行哪些查询，请运行以下查询：
```
select user_name, db_name, pid, query
from stv_recents
where status = 'Running';
```
下面的示例输出显示对 TICKIT 数据库运行的单个查询：
```
user_name | db_name | pid | query
----------+---------+---------+-------------
dwuser | tickit | 19996 |select venuename, venueseats from
venue where venueseats > 50000 order by venueseats desc;
```
以下示例返回正在运行或者在队列中等待运行的查询（如果有）的列表：
```
select * from stv_recents where status<>'Done';
status | starttime | duration |user_name|db_name| query | pid
-------+---------------------+----------+---------+-------+-----------+------
Running| 2010-04-21 16:11... | 281566454| dwuser |tickit | select ...| 23347
```
此查询不返回结果，除非正在运行一些并发查询，而其中一些查询位于队列中。
以下示例扩展前一示例。在此示例中，从结果中排除真正“正在进行”（正在运行，未在等待）的查询：
```
select * from stv_recents where status<>'Done'
and pid not in (select pid from stv_inflight);
...
```
有关排除查询性能故障的更多提示，请参阅[查询故障排除](queries-troubleshooting.md)。
# STV\$1SESSIONS
使用 STV\$1SESSIONS 表可以查看有关 Amazon Redshift 的活动用户会话的信息。
要查看会话历史记录，请使用 [STL\$1SESSIONS](r_STL_SESSIONS.md) 表而非 STV\$1SESSIONS。
STV\$1SESSIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_SESSIONS.html)
## 示例查询
要执行快速检查以了解是否有任何其他用户当前登录到 Amazon Redshift，请键入以下查询：
```
select count(*)
from stv_sessions;
```
如果结果大于 1，则表示至少有一个其他用户当前登录到该数据库。
要查看 Amazon Redshift 的所有活动会话，请键入以下查询：
```
select *
from stv_sessions;
```
下面的结果显示当前在 Amazon Redshift 上运行的四个活动会话：
```
starttime | process |user_name | db_name | timeout_sec
-------------------------+---------+----------------------------+----------------------------+-------------
2018-08-06 08:44:07.50 | 13779 | IAMA:aws_admin:admin_grp | dev | 0
2008-08-06 08:54:20.50 | 19829 | dwuser | dev | 120
2008-08-06 08:56:34.50 | 20279 | dwuser | dev | 120
2008-08-06 08:55:00.50 | 19996 | dwuser | tickit | 0
(3 rows)
```
前缀为 IAMA 的用户名表示此用户是使用联合单点登录进行登录的。有关更多信息，请参阅[使用 IAM 身份验证生成数据库用户凭证](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html)。
# STV\$1SLICES
使用 STV\$1SLICES 表可以查看分片到节点的当前映射。
STV\$1SLICES 中的信息主要用于调查目的。
STV\$1SLICES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_SLICES.html)
## 示例查询
要查看哪些集群节点管理哪些分片，请键入以下查询：
```
select node, slice from stv_slices;
```
此查询返回以下示例输出：
```
node | slice
------+-------
0 | 2
0 | 3
0 | 1
0 | 0
(4 rows)
```
# STV\$1STARTUP\$1RECOVERY\$1STATE
记录在执行集群重新启动操作期间临时锁定的表的状态。Amazon Redshift 对于正在处理以解决集群重新启动后过时的事务的表，会临时锁定这些表。
STV\$1STARTUP\$1RECOVERY\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_STARTUP_RECOVERY_STATE.html)
## 示例查询
要监控临时锁定了哪些表，请在集群重新启动之后运行以下查询。
```
select * from STV_STARTUP_RECOVERY_STATE;
db_id | tbl_id | table_name
--------+--------+------------
100044 | 100058 | lineorder
100044 | 100068 | part
100044 | 100072 | customer
100044 | 100192 | supplier
(4 rows)
```
# STV\$1TBL\$1PERM
STV\$1TBL\$1PERM 表包含有关 Amazon Redshift 中永久表的信息，其中包括用户为当前会话创建的临时表。STV\$1TBL\$1PERM 包含所有数据库中的所有表的信息。
此表不同于 [STV\$1TBL\$1TRANS](r_STV_TBL_TRANS.md)，后者包含有关系统在查询处理期间创建的临时数据库表的信息。
STV\$1TBL\$1PERM 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_TBL_PERM.html)
## 示例查询
以下查询返回不同表 ID 和名称的列表：
```
select distinct id, name
from stv_tbl_perm order by name;
id | name
--------+-------------------------
100571 | category
100575 | date
100580 | event
100596 | listing
100003 | padb_config_harvest
100612 | sales
...
```
其他系统表使用表 ID，因此知道特定表对应于哪个表 ID 会非常有用。在此示例中，SELECT DISTINCT 用于删除重复项（表分布在多个分片中）。
要确定 VENUE 表中每一列所使用的块数，请键入以下查询：
```
select col, count(*)
from stv_blocklist, stv_tbl_perm
where stv_blocklist.tbl = stv_tbl_perm.id
and stv_blocklist.slice = stv_tbl_perm.slice
and stv_tbl_perm.name = 'venue'
group by col
order by col;
col | count
-----+-------
0 | 8
1 | 8
2 | 8
3 | 8
4 | 8
5 | 8
6 | 8
7 | 8
(8 rows)
```
## 使用说明
ROWS 列包括尚未真空化（或者已真空化但使用 SORT ONLY 选项）的已删除行的计数。因此，当您直接查询给定表时，STV\$1TBL\$1PERM 表中的 ROWS 列的 SUM 可能与 COUNT(\$1) 结果不符。例如，如果从 VENUE 中删除了两行，则 COUNT(\$1) 结果为 200，但 SUM(ROWS) 结果仍为 202：
```
delete from venue
where venueid in (1,2);
select count(*) from venue;
count
-------
200
(1 row)
select trim(name) tablename, sum(rows)
from stv_tbl_perm where name='venue' group by name;
tablename | sum
-----------+-----
venue | 202
(1 row)
```
要同步 STV\$1TBL\$1PERM 中的数据，请对 VENUE 表运行完全真空化。
```
vacuum venue;
select trim(name) tablename, sum(rows)
from stv_tbl_perm
where name='venue'
group by name;
tablename | sum
-----------+-----
venue | 200
(1 row)
```
# STV\$1TBL\$1TRANS
使用 STV\$1TBL\$1TRANS 表可以找到有关当前位于内存中的临时数据库表的信息。
临时表通常是在运行查询时用作中间结果的临时行集。STV\$1TBL\$1TRANS 不同于 [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)，因为 STV\$1TBL\$1PERM 包含有关永久数据库表的信息。
STV\$1TBL\$1TRANS 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_TBL_TRANS.html)
## 示例查询
要查看查询 ID 为 90 的查询的临时表信息，请键入以下命令：
```
select slice, id, rows, size, query_id, ref_cnt
from stv_tbl_trans
where query_id = 90;
```
此查询返回查询 90 的临时表信息，如以下示例输出中所示：
```
slice | id | rows | size | query_ | ref_ | from_ | prep_
| | | | id | cnt | suspended | swap
------+----+------+------+--------+------+-----------+-------
1013 | 95 | 0 | 0 | 90 | 4 | 0 | 0
7 | 96 | 0 | 0 | 90 | 4 | 0 | 0
10 | 96 | 0 | 0 | 90 | 4 | 0 | 0
17 | 96 | 0 | 0 | 90 | 4 | 0 | 0
14 | 96 | 0 | 0 | 90 | 4 | 0 | 0
3 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 99 | 0 | 0 | 90 | 4 | 0 | 0
9 | 96 | 0 | 0 | 90 | 4 | 0 | 0
5 | 96 | 0 | 0 | 90 | 4 | 0 | 0
19 | 96 | 0 | 0 | 90 | 4 | 0 | 0
2 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 98 | 0 | 0 | 90 | 4 | 0 | 0
13 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1 | 96 | 0 | 0 | 90 | 4 | 0 | 0
1013 | 96 | 0 | 0 | 90 | 4 | 0 | 0
6 | 96 | 0 | 0 | 90 | 4 | 0 | 0
11 | 96 | 0 | 0 | 90 | 4 | 0 | 0
15 | 96 | 0 | 0 | 90 | 4 | 0 | 0
18 | 96 | 0 | 0 | 90 | 4 | 0 | 0
```
在此示例中，您可以看到查询数据涉及表 95、96 和 98。由于未向此表分配任何字节数，因此可在内存中运行此查询。
# STV\$1WLM\$1CLASSIFICATION\$1CONFIG
包含 WLM 的当前分类规则。
STV\$1WLM\$1CLASSIFICATION\$1CONFIG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_CLASSIFICATION_CONFIG.html)
## 示例查询
```
select * from STV_WLM_CLASSIFICATION_CONFIG;
id | condition | action_seq | action | action_service_class
---+---------------------------------------------+------------+--------+---------------------
1 | (system user) and (query group: health) | 0 | assign | 1
2 | (system user) and (query group: metrics) | 0 | assign | 2
3 | (system user) and (query group: cmstats) | 0 | assign | 3
4 | (system user) | 0 | assign | 4
5 | (super user) and (query group: superuser) | 0 | assign | 5
6 | (query group: querygroup1) | 0 | assign | 6
7 | (user group: usergroup1) | 0 | assign | 6
8 | (user group: usergroup2) | 0 | assign | 7
9 | (query group: querygroup3) | 0 | assign | 8
10 | (query group: querygroup4) | 0 | assign | 9
11 | (user group: usergroup4) | 0 | assign | 9
12 | (query group: querygroup*) | 0 | assign | 10
13 | (user group: usergroup*) | 0 | assign | 10
14 | (querytype: any) | 0 | assign | 11
(4 rows)
```
# STV\$1WLM\$1QMR\$1CONFIG
记录 WLM 查询监控规则 (QMR) 的配置。有关更多信息，请参阅 [WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。
STV\$1WLM\$1QMR\$1CONFIG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_QMR_CONFIG.html)
## 示例查询
要查看 5 以上的所有服务类（包括用户定义的队列）的 QMR 规则定义，请运行以下查询。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
```
Select *
from stv_wlm_qmr_config
where service_class > 5
order by service_class;
```
# STV\$1WLM\$1QUERY\$1QUEUE\$1STATE
记录服务类的查询队列的当前状态。
STV\$1WLM\$1QUERY\$1QUEUE\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_QUERY_QUEUE_STATE.html)
## 示例查询
以下查询显示 4 个以上服务类的队列中的查询。
```
select * from stv_wlm_query_queue_state
where service_class > 4
order by service_class;
```
此查询返回以下示例输出。
```
service_class | position | task | query | slot_count | start_time | queue_time
---------------+----------+------+-------+------------+----------------------------+------------
5 | 0 | 455 | 476 | 5 | 2010-10-06 13:18:24.065838 | 20937257
6 | 1 | 456 | 478 | 5 | 2010-10-06 13:18:26.652906 | 18350191
(2 rows)
```
# STV\$1WLM\$1QUERY\$1STATE
记录 WLM 正在跟踪的查询的当前状态。
STV\$1WLM\$1QUERY\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_QUERY_STATE.html)
## 示例查询
以下查询显示当前正在 4 以上服务类中执行的所有查询。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
```
select xid, query, trim(state) as state, queue_time, exec_time
from stv_wlm_query_state
where service_class > 4;
```
此查询返回以下示例输出：
```
xid | query | state | queue_time | exec_time
-------+-------+---------+------------+-----------
100813 | 25942 | Running | 0 | 1369029
100074 | 25775 | Running | 0 | 2221589242
```
# STV\$1WLM\$1QUERY\$1TASK\$1STATE
包含服务类查询任务的当前状态。
STV\$1WLM\$1QUERY\$1TASK\$1STATE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_QUERY_TASK_STATE.html)
## 示例查询
以下查询显示当前 4 以上服务类中查询的当前状态。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
```
select * from stv_wlm_query_task_state
where service_class > 4;
```
此查询返回以下示例输出：
```
service_class | task | query | start_time | exec_time
--------------+------+-------+----------------------------+-----------
5 | 466 | 491 | 2010-10-06 13:29:23.063787 | 357618748
(1 row)
```
# STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG
记录 WLM 的服务类配置。
STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_CONFIG.html)
## 示例查询
第一个用户定义的服务类为服务类 6（名为 Service class \$11）。以下查询显示 4 以上的服务类的当前配置。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
```
select rtrim(name) as name,
num_query_tasks as slots,
query_working_mem as mem,
max_execution_time as max_time,
user_group_wild_card as user_wildcard,
query_group_wild_card as query_wildcard
from stv_wlm_service_class_config
where service_class > 4;
name | slots | mem | max_time | user_wildcard | query_wildcard
-----------------------------+-------+-----+----------+---------------+---------------
Service class for super user | 1 | 535 | 0 | false | false
Queue 1 | 5 | 125 | 0 | false | false
Queue 2 | 5 | 125 | 0 | false | false
Queue 3 | 5 | 125 | 0 | false | false
Queue 4 | 5 | 627 | 0 | false | false
Queue 5 | 5 | 125 | 0 | true | true
Default queue | 5 | 125 | 0 | false | false
```
以下查询显示动态 WLM 转换的状态。转换过程中，`num_query_tasks` 和 `target_query_working_mem` 会进行更新，直至等于目标值。有关更多信息，请参阅 [WLM 动态和静态配置属性](cm-c-wlm-dynamic-properties.md)。
```
select rtrim(name) as name,
num_query_tasks as slots,
target_num_query_tasks as target_slots,
query_working_mem as memory,
target_query_working_mem as target_memory
from stv_wlm_service_class_config
where num_query_tasks > target_num_query_tasks
or query_working_mem > target_query_working_mem
and service_class > 5;
name | slots | target_slots | memory | target_mem
------------------+-------+--------------+--------+------------
Queue 3 | 5 | 15 | 125 | 375
Queue 5 | 10 | 5 | 250 | 125
(2 rows)
```
# STV\$1WLM\$1SERVICE\$1CLASS\$1STATE
包含服务类的当前状态。
STV\$1WLM\$1SERVICE\$1CLASS\$1STATE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_STATE.html)
## 示例查询
以下查询显示 5 以上服务类的状态。有关服务类 ID 的列表，请参阅 [WLM 服务类 ID](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids)。
```
select service_class, num_executing_queries,
num_executed_queries
from stv_wlm_service_class_state
where service_class > 5
order by service_class;
```
```
service_class | num_executing_queries | num_executed_queries
---------------+-----------------------+----------------------
6 | 1 | 222
7 | 0 | 135
8 | 1 | 39
(3 rows)
```
# STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE
在经典大小调整期间，使用 STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE 监控每个表的迁移进度。当目标节点类型为 RA3 时，这特别适用。有关 RA3 节点经典大小调整的更多信息，请转到[经典大小调整](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_STV_XRESTORE_ALTER_QUEUE_STATE.html)
## 示例查询
以下查询显示了数据库中正在等待大小调整、当前正进行大小调整和已完成大小调整的表的数量。
```
select db_id, status, count(*)
from stv_xrestore_alter_queue_state
group by 1,2 order by 3 desc
db_id | status | count
-------+------------+------
694325 | Waiting | 323
694325 | Finished | 60
694325 | Applying | 1
```
# 主集群和并发扩展集群的 SVCS 视图
带有前缀 SVCS 的 SVCS 系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
**Topics**
+ [SVCS\$1ALERT\$1EVENT\$1LOG](r_SVCS_ALERT_EVENT_LOG.md)
+ [SVCS\$1COMPILE](r_SVCS_COMPILE.md)
+ [SVCS\$1CONCURRENCY\$1SCALING\$1USAGE](r_SVCS_CONCURRENCY_SCALING_USAGE.md)
+ [SVCS\$1EXPLAIN](r_SVCS_EXPLAIN.md)
+ [SVCS\$1PLAN\$1INFO](r_SVCS_PLAN_INFO.md)
+ [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md)
+ [SVCS\$1S3LIST](r_SVCS_S3LIST.md)
+ [SVCS\$1S3LOG](r_SVCS_S3LOG.md)
+ [SVCS\$1S3PARTITION\$1SUMMARY](r_SVCS_S3PARTITION_SUMMARY.md)
+ [SVCS\$1S3QUERY\$1SUMMARY](r_SVCS_S3QUERY_SUMMARY.md)
+ [SVCS\$1STREAM\$1SEGS](r_SVCS_STREAM_SEGS.md)
+ [SVCS\$1UNLOAD\$1LOG](r_SVCS_UNLOAD_LOG.md)
# SVCS\$1ALERT\$1EVENT\$1LOG
当查询优化程序发现可能指示性能问题的条件时记录警报。该视图派生自 STL\$1ALERT\$1EVENT\$1LOG 系统表，但不显示在并发扩展集群上运行的查询的切片级别。使用 SVCS\$1ALERT\$1EVENT\$1LOG 表标识用于改进查询性能的机会。
一个查询包含多个区段，而且每个区段包含一个或多个步骤。有关更多信息，请参阅 [查询处理](c-query-processing.md)。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
SVCS\$1ALERT\$1EVENT\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_ALERT_EVENT_LOG.html)
## 使用说明
您可以使用 SVCS\$1ALERT\$1EVENT\$1LOG 来标识查询中的潜在问题，然后按照[查询性能优化](c-optimizing-query-performance.md)中的做法来优化数据库设计并重新编写查询。SVCS\$1ALERT\$1EVENT\$1LOG 将记录以下警报：
+ **缺失统计数据**
统计数据缺失。在加载数据或进行大量更改之后运行 ANALYZE 并结合使用 STATUPDATE 和 COPY 操作。有关更多信息，请参阅 [设计查询的 Amazon Redshift 最佳实践](c_designing-queries-best-practices.md)。
+ **嵌套循环**
一个嵌套循环通常是一个笛卡尔积。评估您的查询以确保所有参与表均已高效地联接。
+ **选择性非常强的筛选条件**
返回的行与扫描的行的比率小于 0.05。扫描的行是 `rows_pre_user_filter `的值，而返回的行是 [STL\$1SCAN](r_STL_SCAN.md) 系统表中的行的值。表示查询正在扫描数量极其大的行来确定结果集。这可能是由于排序键缺失或不正确导致的。有关更多信息，请参阅 [排序键](t_Sorting_data.md)。
+ **过多的虚影行**
扫描跳过了相对大量的标记为已删除但未抽空的行或已插入但未提交的行。有关更多信息，请参阅 [对表执行 vacuum 操作](t_Reclaiming_storage_space202.md)。
+ **大型分配**
为进行哈希联接或聚合重新分配了超过 1000000 的行。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
+ **大型广播**
为进行哈希联接广播了超过了 1000000 的行。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
+ **顺序执行**
DS\$1DIST\$1ALL\$1INNER 重新分配方式已在查询计划中指明，此方式强制实施序列执行，因为整个内部表已重新分配到单个节点。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
## 示例查询
以下查询显示了四种查询的警报事件。
```
SELECT query, substring(event,0,25) as event,
substring(solution,0,25) as solution,
trim(event_time) as event_time from svcs_alert_event_log order by query;
query | event | solution | event_time
-------+-------------------------------+------------------------------+---------------------
6567 | Missing query planner statist | Run the ANALYZE command | 2014-01-03 18:20:58
7450 | Scanned a large number of del | Run the VACUUM command to rec| 2014-01-03 21:19:31
8406 | Nested Loop Join in the query | Review the join predicates to| 2014-01-04 00:34:22
29512 | Very selective query filter:r | Review the choice of sort key| 2014-01-06 22:00:00
(4 rows)
```
# SVCS\$1COMPILE
记录查询（包括在扩展集群上运行的查询以及在主集群上运行的查询）的每个查询段的编译时间和位置。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1COMPILE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SCL\$1COMPILE 的信息，请参阅 [SVL\$1COMPILE](r_SVL_COMPILE.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_COMPILE.html)
## 示例查询
在本示例中，查询 35878 和 35879 运行相同的 SQL 语句。查询 35878 的编译列针对四个查询段均显示 `1`，表明这些段得到编译。查询 35879 的编译列针对每个段均显示 `0`，表明这些段无需再次编译。
```
select userid, xid, pid, query, segment, locus,
datediff(ms, starttime, endtime) as duration, compile
from svcs_compile
where query = 35878 or query = 35879
order by query, segment;
userid | xid | pid | query | segment | locus | duration | compile
--------+--------+-------+-------+---------+-------+----------+---------
100 | 112780 | 23028 | 35878 | 0 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 1 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 2 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 3 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 4 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 5 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 6 | 1 | 1380 | 1
100 | 112780 | 23028 | 35878 | 7 | 1 | 1085 | 1
100 | 112780 | 23028 | 35878 | 8 | 1 | 1197 | 1
100 | 112780 | 23028 | 35878 | 9 | 2 | 905 | 1
100 | 112782 | 23028 | 35879 | 0 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 1 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 2 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 3 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 4 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 5 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 6 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 7 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 8 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 9 | 2 | 0 | 0
(20 rows)
```
# SVCS\$1CONCURRENCY\$1SCALING\$1USAGE
记录并发扩展的使用期。每个使用期是单个并发扩展集群主动处理查询的连续的持续时间。
SVCS\$1CONCURRENCY\$1SCALING\$1USAGE 对超级用户可见。数据库超级用户可以选择为所有用户打开该视图。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_CONCURRENCY_SCALING_USAGE.html)
## 示例查询
要查看特定时间段的使用持续时间（以秒为单位），请输入以下查询：
```
select * from svcs_concurrency_scaling_usage order by start_time;
start_time | end_time | queries | usage_in_seconds
----------------------------+----------------------------+---------+------------------
2019-02-14 18:43:53.01063 | 2019-02-14 19:16:49.781649 | 48 | 1977
```
# SVCS\$1EXPLAIN
显示已提交供执行的查询的 EXPLAIN 计划。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
SVCS\$1EXPLAIN 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_EXPLAIN.html)
## 示例查询
考虑聚合联接查询的以下 EXPLAIN 输出：
```
explain select avg(datediff(day, listtime, saletime)) as avgwait
from sales, listing where sales.listid = listing.listid;
QUERY PLAN
------------------------------------------------------------------------------
XN Aggregate (cost=6350.30..6350.31 rows=1 width=16)
-> XN Hash Join DS_DIST_NONE (cost=47.08..6340.89 rows=3766 width=16)
Hash Cond: ("outer".listid = "inner".listid)
-> XN Seq Scan on listing (cost=0.00..1924.97 rows=192497 width=12)
-> XN Hash (cost=37.66..37.66 rows=3766 width=12)
-> XN Seq Scan on sales (cost=0.00..37.66 rows=3766 width=12)
(6 rows)
```
如果您运行此查询且其查询 ID 为 10，则您可以使用 SVCS\$1EXPLAIN 表来查看 EXPLAIN 命令返回的同类信息：
```
select query,nodeid,parentid,substring(plannode from 1 for 30),
substring(info from 1 for 20) from svcs_explain
where query=10 order by 1,2;
query| nodeid |parentid| substring | substring
-----+--------+--------+--------------------------------+-------------------
10 | 1 | 0 |XN Aggregate (cost=6717.61..6 |
10 | 2 | 1 | -> XN Merge Join DS_DIST_NO| Merge Cond:("outer"
10 | 3 | 2 | -> XN Seq Scan on lis |
10 | 4 | 2 | -> XN Seq Scan on sal |
(4 rows)
```
请考虑以下查询：
```
select event.eventid, sum(pricepaid)
from event, sales
where event.eventid=sales.eventid
group by event.eventid order by 2 desc;
eventid | sum
--------+----------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
...
```
如果此查询的 ID 为 15，则以下系统表查询返回已完成的计划节点。在这种情况下，将反转节点的顺序以显示执行的实际顺序：
```
select query,nodeid,parentid,substring(plannode from 1 for 56)
from svcs_explain where query=15 order by 1, 2 desc;
query|nodeid|parentid| substring
-----+------+--------+--------------------------------------------------------
15 | 8 | 7 | -> XN Seq Scan on eve
15 | 7 | 5 | -> XN Hash(cost=87.98..87.9
15 | 6 | 5 | -> XN Seq Scan on sales(cos
15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos
15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07..
15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871
15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197.
15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87
(8 rows)
```
以下查询检索包含一个窗口函数的任何查询计划的查询 ID：
```
select query, trim(plannode) from svcs_explain
where plannode like '%Window%';
query| btrim
-----+------------------------------------------------------------------------
26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
(2 rows)
```
# SVCS\$1PLAN\$1INFO
使用 SVCS\$1PLAN\$1INFO 表以一组行的形式查看一个查询的 EXPLAIN 输出。这是查看查询计划的一种替代方法。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
SVCS\$1PLAN\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_PLAN_INFO.html)
## 示例查询
以下示例比较了通过使用 EXPLAIN 命令和通过查询 SVCS\$1PLAN\$1INFO 表返回的简单 SELECT 查询的查询计划。
```
explain select * from category;
QUERY PLAN
-------------------------------------------------------------
XN Seq Scan on category (cost=0.00..0.11 rows=11 width=49)
(1 row)
select * from category;
catid | catgroup | catname | catdesc
-------+----------+-----------+--------------------------------------------
1 | Sports | MLB | Major League Baseball
3 | Sports | NFL | National Football League
5 | Sports | MLS | Major League Soccer
...
select * from svcs_plan_info where query=256;
query | nodeid | segment | step | locus | plannode | startupcost | totalcost
| rows | bytes
-------+--------+---------+------+-------+----------+-------------+-----------+------+-------
256 | 1 | 0 | 1 | 0 | 104 | 0 | 0.11 | 11 | 539
256 | 1 | 0 | 0 | 0 | 104 | 0 | 0.11 | 11 | 539
(2 rows)
```
在本示例中，PLANNODE 104 表示 CATEGORY 表的顺序扫描。
```
select distinct eventname from event order by 1;
eventname
------------------------------------------------------------------------
.38 Special
3 Doors Down
70s Soul Jam
A Bronx Tale
...
explain select distinct eventname from event order by 1;
QUERY PLAN
-------------------------------------------------------------------------------------
XN Merge (cost=1000000000136.38..1000000000137.82 rows=576 width=17)
Merge Key: eventname
-> XN Network (cost=1000000000136.38..1000000000137.82 rows=576
width=17)
Send to leader
-> XN Sort (cost=1000000000136.38..1000000000137.82 rows=576
width=17)
Sort Key: eventname
-> XN Unique (cost=0.00..109.98 rows=576 width=17)
-> XN Seq Scan on event (cost=0.00..87.98 rows=8798
width=17)
(8 rows)
select * from svcs_plan_info where query=240 order by nodeid desc;
query | nodeid | segment | step | locus | plannode | startupcost |
totalcost | rows | bytes
-------+--------+---------+------+-------+----------+------------------+------------------+------+--------
240 | 5 | 0 | 0 | 0 | 104 | 0 | 87.98 | 8798 | 149566
240 | 5 | 0 | 1 | 0 | 104 | 0 | 87.98 | 8798 | 149566
240 | 4 | 0 | 2 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 0 | 3 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 1 | 0 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 4 | 1 | 1 | 0 | 117 | 0 | 109.975 | 576 | 9792
240 | 3 | 1 | 2 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 3 | 2 | 0 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 2 | 2 | 1 | 0 | 123 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
240 | 1 | 3 | 0 | 0 | 122 | 1000000000136.38 | 1000000000137.82 | 576 | 9792
(10 rows)
```
# SVCS\$1QUERY\$1SUMMARY
使用 SVCS\$1QUERY\$1SUMMARY 视图查找有关查询执行的一般信息。
注意，SVCS\$1QUERY\$1SUMMARY 中的信息来自对所有节点的汇总。
**注意**
SVCS\$1QUERY\$1SUMMARY 视图只包含有关 Amazon Redshift 完成的查询的信息，不包含其它实用工具和 DDL 命令执行的查询的相关信息。有关 Amazon Redshift（包括 DDL 和实用工具命令）完成的所有语句的完整列表和信息，请查询 SVL\$1STATEMENTTEXT 视图。
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1QUERY\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
有关 SVL\$1QUERY\$1SUMMARY 的信息，请参阅 [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_QUERY_SUMMARY.html)
## 示例查询
**查看查询步骤的处理信息**
下面的查询显示查询 87 的每个步骤的基本处理信息：
```
select query, stm, seg, step, rows, bytes
from svcs_query_summary
where query = 87
order by query, seg, step;
```
此查询检索有关查询 87 的处理信息，如下面的示例输出所示：
```
query | stm | seg | step | rows | bytes
-------+-----+-----+------+--------+---------
87 | 0 | 0 | 0 | 90 | 1890
87 | 0 | 0 | 2 | 90 | 360
87 | 0 | 1 | 0 | 90 | 360
87 | 0 | 1 | 2 | 90 | 1440
87 | 1 | 2 | 0 | 210494 | 4209880
87 | 1 | 2 | 3 | 89500 | 0
87 | 1 | 2 | 6 | 4 | 96
87 | 2 | 3 | 0 | 4 | 96
87 | 2 | 3 | 1 | 4 | 96
87 | 2 | 4 | 0 | 4 | 96
87 | 2 | 4 | 1 | 1 | 24
87 | 3 | 5 | 0 | 1 | 24
87 | 3 | 5 | 4 | 0 | 0
(13 rows)
```
**确定查询步骤是否溢出到磁盘**
下面的查询显示查询 ID 为 1025 的查询是否有任何步骤（有关如何获取查询 ID 的信息，请参阅 [SVL\$1QLOG](r_SVL_QLOG.md) 视图）溢出到磁盘，还是查询完全在内存中运行：
```
select query, step, rows, workmem, label, is_diskbased
from svcs_query_summary
where query = 1025
order by workmem desc;
```
此查询返回以下示例输出：
```
query| step| rows | workmem | label | is_diskbased
-----+-----+--------+-----------+---------------+--------------
1025 | 0 |16000000| 141557760 |scan tbl=9 | f
1025 | 2 |16000000| 135266304 |hash tbl=142 | t
1025 | 0 |16000000| 128974848 |scan tbl=116536| f
1025 | 2 |16000000| 122683392 |dist | f
(4 rows)
```
通过扫描 IS\$1DISKBASED 的值，您能够了解哪些查询步骤溢出到磁盘。对于查询 1025，哈希步骤在磁盘上运行。可能在磁盘上执行的步骤包括哈希、聚合和排序步骤。要仅查看基于磁盘的查询步骤，请在上面的示例中向 SQL 语句添加 **and is\$1diskbased = 't'** 子句。
# SVCS\$1S3LIST
可以使用 SVCS\$1S3LIST 视图获取有关段级别的 Amazon Redshift Spectrum 查询的详细信息。一个段可以执行一个外部表扫描。该视图派生自 SVL\$1S3LIST 系统视图，但不显示在并发扩展集群上运行的查询的切片级别。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1S3LIST 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SVL\$1S3LIST 的信息，请参阅 [SVL\$1S3LIST](r_SVL_S3LIST.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_S3LIST.html)
## 示例查询
以下示例查询上次执行的查询的 SVCS\$1S3LIST。
```
select *
from svcs_s3list
where query = pg_last_query_id()
order by query,segment;
```
# SVCS\$1S3LOG
可以使用 SVCS\$1S3LOG 视图获取有关段级别的 Redshift Spectrum 查询的故障排除详细信息。一个段可以执行一个外部表扫描。该视图派生自 SVL\$1S3LOG 系统视图，但不显示在并发扩展集群上运行的查询的切片级别。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1S3LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SVL\$1S3LOG 的信息，请参阅 [SVL\$1S3LOG](r_SVL_S3LOG.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_S3LOG.html)
## 示例查询
以下示例查询上次运行的查询的 SVCS\$1S3LOG。
```
select *
from svcs_s3log
where query = pg_last_query_id()
order by query,segment;
```
# SVCS\$1S3PARTITION\$1SUMMARY
可以使用 SVCS\$1S3PARTITION\$1SUMMARY 视图获取段级别的 Redshift Spectrum 查询分区处理摘要。一个段可以执行一个外部表扫描。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1S3PARTITION\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SVL\$1S3PARTITION 的信息，请参阅 [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_S3PARTITION_SUMMARY.html)
## 示例查询
以下示例获取上次执行的查询的分区扫描详细信息。
```
select query, segment, assignment, min_starttime, max_endtime, min_duration, avg_duration
from svcs_s3partition_summary
where query = pg_last_query_id()
order by query,segment;
```
# SVCS\$1S3QUERY\$1SUMMARY
可以使用 SVCS\$1S3QUERY\$1SUMMARY 视图获取已在系统上运行的所有 Redshift Spectrum 查询（S3 查询）的摘要。一个段可以执行一个外部表扫描。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 SVL 的视图类似，但 SVL 视图仅提供在主集群上运行的查询的信息。
SVCS\$1S3QUERY\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SVL\$1S3QUERY 的信息，请参阅 [SVL\$1S3QUERY](r_SVL_S3QUERY.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_S3QUERY_SUMMARY.html)
## 示例查询
以下示例获取上次运行的查询的扫描步骤详细信息。
```
select query, segment, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files
from svcs_s3query_summary
where query = pg_last_query_id()
order by query,segment;
```
```
query | segment | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files
------+---------+---------+-----------------+------------------+-----------------------+------------------------+------
4587 | 2 | 67811 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1
4587 | 2 | 216849 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 216671 | 0 | 0 | 0 | 0 | 0
```
# SVCS\$1STREAM\$1SEGS
列出流与并发分段之间的关系。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
SVCS\$1STREAM\$1SEGS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_STREAM_SEGS.html)
## 示例查询
要查看最近查询的流与并发分段之间的关系，请键入以下查询：
```
select *
from svcs_stream_segs
where query = pg_last_query_id();
query | stream | segment
-------+--------+---------
10 | 1 | 2
10 | 0 | 0
10 | 2 | 4
10 | 1 | 3
10 | 0 | 1
(5 rows)
```
# SVCS\$1UNLOAD\$1LOG
可以使用 SVCS\$1UNLOAD\$1LOG 获取 UNLOAD 操作的详细信息。
SVCS\$1UNLOAD\$1LOG 为 UNLOAD 语句创建的每个文件记录一行。例如，如果 UNLOAD 创建 12 个文件，则 SVCS\$1UNLOAD\$1LOG 包含 12 个相应的行。该视图派生自 STL\$1UNLOAD\$1LOG 系统表，但不显示在并发扩展集群上运行的查询的切片级别。
**注意**
带有前缀 SVCS 的系统视图提供了有关主集群和并发扩展集群上的查询的详细信息。这些视图与带有前缀 STL 的表类似，但 STL 表仅提供在主集群上运行的查询的信息。
SVCS\$1UNLOAD\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVCS_UNLOAD_LOG.html)
## 示例查询
要获得已由 UNLOAD 命令写入到 Amazon S3 的文件的列表，您可以在 UNLOAD 完成后调用 Amazon S3 列表操作；但是，根据您发出调用的速度，列表可能不完整，因为 Amazon S3 列表操作最终是一致的。要立即获得完整的权威列表，请查询 SVCS\$1UNLOAD\$1LOG。
以下查询返回上次完成的查询的 UNLOAD 创建的文件的路径名：
```
select query, substring(path,0,40) as path
from svcs_unload_log
where query = pg_last_query_id()
order by path;
```
此命令返回以下示例输出：
```
query | path
------+---------------------------------------------
2320 | s3://amzn-s3-demo-bucket/venue0000_part_00
2320 | s3://amzn-s3-demo-bucket/venue0001_part_00
2320 | s3://amzn-s3-demo-bucket/venue0002_part_00
2320 | s3://amzn-s3-demo-bucket/venue0003_part_00
(4 rows)
```
# 主集群的 SVL 视图
SVL 视图是 Amazon Redshift 中的系统视图，其中包含对 STL 表和日志的引用以提供更多详细信息。
这些视图提供对在这些表中找到的常用查询数据的更快速、更便捷的访问。
**注意**
SVL\$1QUERY\$1SUMMARY 视图只包含有关 Amazon Redshift 运行的查询的信息，不包含其它实用工具和 DDL 命令执行的查询的相关信息。有关 Amazon Redshift（包括 DDL 和实用工具命令）运行的所有语句的完整列表和信息，请查询 SVL\$1STATEMENTTEXT 视图。
**Topics**
+ [SVL\$1AUTO\$1WORKER\$1ACTION](r_SVL_AUTO_WORKER_ACTION.md)
+ [SVL\$1COMPILE](r_SVL_COMPILE.md)
+ [SVL\$1DATASHARE\$1CHANGE\$1LOG](r_SVL_DATASHARE_CHANGE_LOG.md)
+ [SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SVL_DATASHARE_CROSS_REGION_USAGE.md)
+ [SVL\$1DATASHARE\$1USAGE\$1CONSUMER](r_SVL_DATASHARE_USAGE_CONSUMER.md)
+ [SVL\$1DATASHARE\$1USAGE\$1PRODUCER](r_SVL_DATASHARE_USAGE_PRODUCER.md)
+ [SVL\$1FEDERATED\$1QUERY](r_SVL_FEDERATED_QUERY.md)
+ [SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS](r_SVL_MULTI_STATEMENT_VIOLATIONS.md)
+ [SVL\$1MV\$1REFRESH\$1STATUS](r_SVL_MV_REFRESH_STATUS.md)
+ [SVL\$1QERROR](r_SVL_QERROR.md)
+ [SVL\$1QLOG](r_SVL_QLOG.md)
+ [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md)
+ [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md)
+ [SVL\$1QUERY\$1QUEUE\$1INFO](r_SVL_QUERY_QUEUE_INFO.md)
+ [SVL\$1QUERY\$1REPORT](r_SVL_QUERY_REPORT.md)
+ [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md)
+ [SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS](r_SVL_RESTORE_ALTER_TABLE_PROGRESS.md)
+ [SVL\$1S3LIST](r_SVL_S3LIST.md)
+ [SVL\$1S3LOG](r_SVL_S3LOG.md)
+ [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md)
+ [SVL\$1S3PARTITION\$1SUMMARY](r_SVL_S3PARTITION_SUMMARY.md)
+ [SVL\$1S3QUERY](r_SVL_S3QUERY.md)
+ [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md)
+ [SVL\$1S3RETRIES](r_SVL_S3RETRIES.md)
+ [SVL\$1SPATIAL\$1SIMPLIFY](r_SVL_SPATIAL_SIMPLIFY.md)
+ [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md)
+ [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)
+ [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md)
+ [SVL\$1STORED\$1PROC\$1MESSAGES](r_SVL_STORED_PROC_MESSAGES.md)
+ [SVL\$1TERMINATE](r_SVL_TERMINATE.md)
+ [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md)
+ [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md)
+ [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)
# SVL\$1AUTO\$1WORKER\$1ACTION
记录 Amazon Redshift 对自动优化定义的表执行的自动操作。
SVL\$1AUTO\$1WORKER\$1ACTION 对所有用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_AUTO_WORKER_ACTION.html)
`status` 列的一些值示例如下所示：
+ 已跳过：找不到表。
+ 已跳过：建议为空。
+ 已跳过：应用排序键建议已禁用。
+ 已跳过：重试次数超出表的最大限制。
+ 已跳过：表列已更改。
+ 中止：此表不是 AUTO。
+ 中止：此表最近已转换。
+ 中止：此表超出表大小阈值。
+ 中止：此表已经是推荐的样式。
+ 检查点：进度 *21.9963*%。
## 示例查询
在以下示例中，结果中的行显示了由 Amazon Redshift 执行的操作。
```
select table_id, type, status, eventtime, sequence, previous_state
from SVL_AUTO_WORKER_ACTION;
```
```
table_id | type | status | eventtime | sequence | previous_state
----------+---------+------------------------------------------------------+----------------------------+----------+----------------
118082 | sortkey | Start | 2020-08-22 19:42:20.727049 | 0 |
118078 | sortkey | Start | 2020-08-22 19:43:54.728819 | 0 |
118082 | sortkey | Start | 2020-08-22 19:42:52.690264 | 0 |
118072 | sortkey | Start | 2020-08-22 19:44:14.793572 | 0 |
118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 | 0 |
118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | 0 | SORTKEY: None;
118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | 0 | SORTKEY: None;
118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | 0 | SORTKEY: None;
118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 | 0 |
118086 | sortkey | Start | 2020-08-22 19:42:00.685255 | 0 |
118082 | sortkey | Start | 2020-08-22 19:43:34.69531 | 0 |
118072 | sortkey | Start | 2020-08-22 19:44:46.703331 | 0 |
118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 | 0 |
118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 | 0 |
116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 | 0 |
110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 | 0 |
```
# SVL\$1COMPILE
记录查询的每个查询段的编译时间和位置。
SVL\$1COMPILE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
SVL\$1COMPILE 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
有关 SVCS\$1COMPILE 的信息，请参阅 [SVCS\$1COMPILE](r_SVCS_COMPILE.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_COMPILE.html)
## 示例查询
在本示例中，查询 35878 和 35879 运行相同的 SQL 语句。查询 35878 的编译列针对四个查询段均显示 `1`，表明这些段得到编译。查询 35879 的编译列针对每个段均显示 `0`，表明这些段无需再次编译。
```
select userid, xid, pid, query, segment, locus,
datediff(ms, starttime, endtime) as duration, compile
from svl_compile
where query = 35878 or query = 35879
order by query, segment;
userid | xid | pid | query | segment | locus | duration | compile
--------+--------+-------+-------+---------+-------+----------+---------
100 | 112780 | 23028 | 35878 | 0 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 1 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 2 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 3 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 4 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 5 | 1 | 0 | 0
100 | 112780 | 23028 | 35878 | 6 | 1 | 1380 | 1
100 | 112780 | 23028 | 35878 | 7 | 1 | 1085 | 1
100 | 112780 | 23028 | 35878 | 8 | 1 | 1197 | 1
100 | 112780 | 23028 | 35878 | 9 | 2 | 905 | 1
100 | 112782 | 23028 | 35879 | 0 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 1 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 2 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 3 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 4 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 5 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 6 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 7 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 8 | 1 | 0 | 0
100 | 112782 | 23028 | 35879 | 9 | 2 | 0 | 0
(20 rows)
```
# SVL\$1DATASHARE\$1CHANGE\$1LOG
记录用于跟踪创建器和使用者集群上的数据共享更改的综合视图。
SVL\$1DATASHARE\$1CHANGE\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_DATASHARE_CHANGE_LOG.html)
## 示例查询
以下示例显示了 SVL\$1DATASHARE\$1CHANGE\$1LOG 视图。
```
SELECT DISTINCT action
FROM svl_datashare_change_log
WHERE share_object_name LIKE 'tickit%';
action
-----------------------
"ALTER DATASHARE ADD"
```
# SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
使用 SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 视图，可以获取跨区域数据共享查询所导致的跨区域数据传输使用情况的摘要。SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 汇总了段级别的详细信息。
SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_DATASHARE_CROSS_REGION_USAGE.html)
## 示例查询
以下示例显示了 SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 视图。
```
SELECT query, segment, transferred_data, source_region
from svl_datashare_cross_region_usage
where query = pg_last_query_id()
order by query,segment;
query | segment | transferred_data | source_region
--------+---------+------------------+---------------
200048 | 2 | 4194304 | us-west-1
200048 | 2 | 4194304 | us-east-2
```
# SVL\$1DATASHARE\$1USAGE\$1CONSUMER
记录数据共享的活动和使用情况。此视图仅与使用者集群相关。
SVL\$1DATASHARE\$1USAGE\$1CONSUMER 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_DATASHARE_USAGE_CONSUMER.html)
## 示例查询
以下示例显示了 SVL\$1DATASHARE\$1USAGE\$1CONSUMER 视图。
```
SELECT request_type, status, trim(error) AS error
FROM svl_datashare_usage_consumer
request_type | status | error
----------------+--------+--------
"GET RELATION" | 0 |
```
# SVL\$1DATASHARE\$1USAGE\$1PRODUCER
记录数据共享的活动和使用情况。此视图仅与创建器集群有关。
SVL\$1DATASHARE\$1USAGE\$1PRODUCER 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_DATASHARE_USAGE_PRODUCER.html)
## 示例查询
以下示例显示了 SVL\$1DATASHARE\$1USAGE\$1PRODUCER 视图。
```
SELECT DISTINCT request_type
FROM svl_datashare_usage_producer
WHERE object_name LIKE 'tickit%';
request_type
------------------
"GET RELATION"
```
# SVL\$1FEDERATED\$1QUERY
使用 SVL\$1FEDERATED\$1QUERY 视图查看有关联合查询调用的信息。
SVL\$1FEDERATED\$1QUERY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_FEDERATED_QUERY.html)
## 示例查询
要显示有关联合查询调用的信息，请运行以下查询。
```
select query, trim(sourcetype) as type, recordtime, trim(querytext) as "PG Subquery" from svl_federated_query where query = 4292;
query | type | recordtime | pg subquery
-------+------+----------------------------+---------------------------------------------------------------
4292 | PG | 2020-03-27 04:29:58.485126 | SELECT "level" FROM functional.employees WHERE ("level" >= 6)
(1 row)
```
# SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS
使用 SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS 视图获取已在系统上运行的违反了事务数据块限制的所有 SQL 命令的完整记录。
当您在事务数据块或多语句请求内运行 Amazon Redshift 限制的以下 SQL 命令时，会发生违规情况：
+ [CREATE DATABASE](r_CREATE_DATABASE.md)
+ [DROP DATABASE](r_DROP_DATABASE.md)
+ [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md)
+ [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md)
+ DROP EXTERNAL TABLE
+ RENAME EXTERNAL TABLE
+ ALTER EXTERNAL TABLE
+ CREATE TABLESPACE。
+ DROP TABLESPACE
+ [CREATE LIBRARY](r_CREATE_LIBRARY.md)
+ [DROP LIBRARY](r_DROP_LIBRARY.md)
+ REBUILDCAT
+ INDEXCAT
+ REINDEX DATABASE
+ [VACUUM](r_VACUUM_command.md)
+ [GRANT](r_GRANT.md)
+ [COPY](r_COPY.md)
**注意**
如果此视图中有任何条目，请更改相应的应用程序和 SQL 脚本。我们建议更改应用程序代码，以便将这些受限 SQL 命令的使用移到事务数据块之外。如果您需要进一步帮助，请联系 AWS Support。
SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_MULTI_STATEMENT_VIOLATIONS.html)
## 示例查询
以下查询返回多个具有违规情况的语句。
```
select * from svl_multi_statement_violations order by starttime asc;
userid | database | cmdname | xid | pid | label | starttime | endtime | sequence | type | text
==============================================================================================================================
1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | DDL | create table c(b int);
1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | UTILITY | create database b;
1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | UTILITY | COMMIT
...
```
# SVL\$1MV\$1REFRESH\$1STATUS
SVL\$1MV\$1REFRESH\$1STATUS 视图包含与具体化视图的刷新活动相对应的一行。
有关具体化视图的更多信息，请参阅[Amazon Redshift 中的实体化视图](materialized-view-overview.md)。
SVL\$1MV\$1REFRESH\$1STATUS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_MV_REFRESH_STATUS.html)
## 示例查询
要查看具体化视图的刷新状态，请运行以下查询。
```
select * from svl_mv_refresh_status;
```
此查询返回以下示例输出：
```
db_name | userid | schema | name | xid | starttime | endtime | status | refresh_type | consumer_account | consumer_region | consumer_namespace
---------+--------+-----------+---------+-------+----------------------------+----------------------------+-------------------------------------------------------------------------------------+---------------+------------------+-----------------+------------------------------------
dev | 169 | mv_schema | mv_test | 6640 | 2020-02-14 02:26:53.497935 | 2020-02-14 02:26:53.556156 | Refresh successfully recomputed MV from scratch | Manual | | |
dev | 166 | mv_schema | mv_test | 6517 | 2020-02-14 02:26:39.287438 | 2020-02-14 02:26:39.349539 | Refresh successfully updated MV incrementally | Auto | | |
ext_db | 162 | producer_schema | producer_mv | 6388 | 2020-02-14 02:26:27.863426 | 2020-02-14 02:26:27.918307 | Refresh successfully updated MV incrementally | Manual | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af
dev | 161 | mv_schema | mv_test | 6323 | 2020-02-14 02:26:20.020717 | 2020-02-14 02:26:20.080002 | Refresh successfully updated MV incrementally | Auto | | |
dev | 161 | mv_schema | mv_test | 6301 | 2020-02-14 02:26:05.796146 | 2020-02-14 02:26:07.853986 | Refresh successfully recomputed MV from scratch | Manual | | |
dev | 153 | mv_schema | mv_test | 6024 | 2020-02-14 02:25:18.762335 | 2020-02-14 02:25:20.043462 | MV was already updated | Manual | | |
dev | 143 | mv_schema | mv_test | 5557 | 2020-02-14 02:24:23.100601 | 2020-02-14 02:24:23.100633 | MV was already updated | Manual
dev | 141 | mv_schema | mv_test | 5447 | 2020-02-14 02:23:54.102837 | 2020-02-14 02:24:00.310166 | Refresh successfully updated MV incrementally | Auto
dev | 1 | mv_schema | mv_test | 5329 | 2020-02-14 02:22:26.328481 | 2020-02-14 02:22:28.369217 | Refresh successfully recomputed MV from scratch | Auto
dev | 138 | mv_schema | mv_test | 5290 | 2020-02-14 02:21:56.885093 | 2020-02-14 02:21:56.885098 | Refresh failed. MV was not found | Manual
dev | 138 | mv_schema | mv_test | 5100 | 2020-02-14 02:20:33.123445 | 2020-02-14 02:20:33.123445 | Cascade refresh failed because materialized view mv_schema.child was not refreshed. | Manual
dev | 138 | mv_schema | child | 5100 | 2020-02-14 02:20:33.123445 | 2020-02-14 02:20:33.123445 | Refresh failed due to an internal error. | Manual
dev | 138 | mv_schema | mv_test | 5099 | 2020-02-14 02:10:23.492344 | 2020-02-14 02:10:23.492344 | Cascade refresh skipped because materialized view mv_schema.child was not refreshed.| Manual
dev | 138 | mv_schema | child | 5099 | 2020-02-14 02:10:23.492344 | 2020-02-14 02:10:23.492344 | Refresh failed due to an internal error. | Manual
```
# SVL\$1QERROR
SVL\$1QERROR 视图已弃用。
# SVL\$1QLOG
SVL\$1QLOG 视图包含针对数据库运行的所有查询的日志。
Amazon Redshift 创建 SVL\$1QLOG 视图作为 [STL\$1QUERY](r_STL_QUERY.md) 表中信息的可读子集。使用该表可找出最近运行的查询的查询 ID，或查看完成某项查询用了多长时间。
SVL\$1QLOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QLOG.html)
## 示例查询
下面的示例返回 `userid = 100` 的用户最近运行的五个数据库查询的查询 ID、执行时间和截断的查询文本。
```
select query, pid, elapsed, substring from svl_qlog
where userid = 100
order by starttime desc
limit 5;
query | pid | elapsed | substring
--------+-------+----------+-----------------------------------------------
187752 | 18921 | 18465685 | select query, elapsed, substring from svl_...
204168 | 5117 | 59603 | insert into testtable values (100);
187561 | 17046 | 1003052 | select * from pg_table_def where tablename...
187549 | 17046 | 1108584 | select * from STV_WLM_SERVICE_CLASS_CONFIG
187468 | 17046 | 5670661 | select * from pg_table_def where schemaname...
(5 rows)
```
下面的示例返回已取消的查询 (**aborted=1**) 的 SQL 脚本名称（LABEL 列）和已用时间：
```
select query, elapsed, trim(label) querylabel
from svl_qlog where aborted=1;
query | elapsed | querylabel
-------+----------+-------------------------
16 | 6935292 | alltickittablesjoin.sql
(1 row)
```
# SVL\$1QUERY\$1METRICS
SVL\$1QUERY\$1METRICS 视图显示已完成的查询的指标。此视图派生自 [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) 系统表。使用此视图中的值以帮助确定用于定义查询监控规则的阈值。有关更多信息，请参阅 [WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。
SVL\$1QUERY\$1METRICS 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QUERY_METRICS.html)
# SVL\$1QUERY\$1METRICS\$1SUMMARY
SVL\$1QUERY\$1METRICS\$1SUMMARY 视图显示已完成的查询的指标的最大值。此视图派生自 [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) 系统表。使用此视图中的值以帮助确定用于定义查询监控规则的阈值。有关 Amazon Redshift 查询监控的规则和指标的更多信息，请参阅[WLM 查询监控规则](cm-c-wlm-query-monitoring-rules.md)。
SVL\$1QUERY\$1METRICS\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QUERY_METRICS_SUMMARY.html)
# SVL\$1QUERY\$1QUEUE\$1INFO
总结查询在工作负载管理 (WLM) 查询队列或提交队列中花费时间的详细信息。
SVL\$1QUERY\$1QUEUE\$1INFO 视图筛选系统执行的查询并且只显示用户执行的查询。
SVL\$1QUERY\$1QUEUE\$1INFO 视图总结 [STL\$1QUERY](r_STL_QUERY.md)、[STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md) 和 [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md) 系统表的信息。
SVL\$1QUERY\$1QUEUE\$1INFO 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QUERY_QUEUE_INFO.html)
## 示例查询
下面的示例显示查询在 WLM 队列中所花费的时间。
```
select query, service_class, queue_elapsed, exec_elapsed, wlm_total_elapsed
from svl_query_queue_info
where wlm_total_elapsed > 0;
query | service_class | queue_elapsed | exec_elapsed | wlm_total_elapsed
---------+---------------+---------------+--------------+-------------------
2742669 | 6 | 2 | 916 | 918
2742668 | 6 | 4 | 197 | 201
(2 rows)
```
# SVL\$1QUERY\$1REPORT
Amazon Redshift 通过对一系列 Amazon Redshift STL 系统表执行 UNION 来创建 SVL\$1QUERY\$1REPORT 视图，以提供有关所完成的查询步骤的信息。
此视图按切片和按步骤细分所完成的查询的相关信息，这有助于诊断 Amazon Redshift 集群中的节点和切片问题。
SVL\$1QUERY\$1REPORT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QUERY_REPORT.html)
## 示例查询
下面的查询演示了针对查询 ID 为 279 的查询返回的行的数据偏斜。使用此查询可以确定数据库数据是否在数据仓库集群中的切片上均匀分配：
```
select query, segment, step, max(rows), min(rows),
case when sum(rows) > 0
then ((cast(max(rows) -min(rows) as float)*count(rows))/sum(rows))
else 0 end
from svl_query_report
where query = 279
group by query, segment, step
order by segment, step;
```
此查询应返回类似以下示例输出的数据：
```
query | segment | step | max | min | case
------+---------+------+----------+----------+----------------------
279 | 0 | 0 | 19721687 | 19721687 | 0
279 | 0 | 1 | 19721687 | 19721687 | 0
279 | 1 | 0 | 986085 | 986084 | 1.01411202804304e-06
279 | 1 | 1 | 986085 | 986084 | 1.01411202804304e-06
279 | 1 | 4 | 986085 | 986084 | 1.01411202804304e-06
279 | 2 | 0 | 1775517 | 788460 | 1.00098637606408
279 | 2 | 2 | 1775517 | 788460 | 1.00098637606408
279 | 3 | 0 | 1775517 | 788460 | 1.00098637606408
279 | 3 | 2 | 1775517 | 788460 | 1.00098637606408
279 | 3 | 3 | 1775517 | 788460 | 1.00098637606408
279 | 4 | 0 | 1775517 | 788460 | 1.00098637606408
279 | 4 | 1 | 1775517 | 788460 | 1.00098637606408
279 | 4 | 2 | 1 | 1 | 0
279 | 5 | 0 | 1 | 1 | 0
279 | 5 | 1 | 1 | 1 | 0
279 | 6 | 0 | 20 | 20 | 0
279 | 6 | 1 | 1 | 1 | 0
279 | 7 | 0 | 1 | 1 | 0
279 | 7 | 1 | 0 | 0 | 0
(19 rows)
```
# SVL\$1QUERY\$1SUMMARY
使用 SVL\$1QUERY\$1SUMMARY 视图查找有关查询执行的一般信息。
SVL\$1QUERY\$1SUMMARY 视图包含 SVL\$1QUERY\$1REPORT 视图的数据子集。注意，SVL\$1QUERY\$1SUMMARY 中的信息来自对所有节点的汇总。
**注意**
SVL\$1QUERY\$1SUMMARY 视图只包含有关 Amazon Redshift 执行的查询的信息，不包含其它实用工具和 DDL 命令执行的查询的相关信息。有关 Amazon Redshift（包括 DDL 和实用工具命令）执行的所有语句的完整列表和信息，请查询 SVL\$1STATEMENTTEXT 视图。
SVL\$1QUERY\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
有关 SVCS\$1QUERY\$1SUMMARY 的信息，请参阅 [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_QUERY_SUMMARY.html)
## 示例查询
**查看查询步骤的处理信息**
下面的查询显示查询 87 的每个步骤的基本处理信息：
```
select query, stm, seg, step, rows, bytes
from svl_query_summary
where query = 87
order by query, seg, step;
```
此查询检索有关查询 87 的处理信息，如下面的示例输出所示：
```
query | stm | seg | step | rows | bytes
-------+-----+-----+------+--------+---------
87 | 0 | 0 | 0 | 90 | 1890
87 | 0 | 0 | 2 | 90 | 360
87 | 0 | 1 | 0 | 90 | 360
87 | 0 | 1 | 2 | 90 | 1440
87 | 1 | 2 | 0 | 210494 | 4209880
87 | 1 | 2 | 3 | 89500 | 0
87 | 1 | 2 | 6 | 4 | 96
87 | 2 | 3 | 0 | 4 | 96
87 | 2 | 3 | 1 | 4 | 96
87 | 2 | 4 | 0 | 4 | 96
87 | 2 | 4 | 1 | 1 | 24
87 | 3 | 5 | 0 | 1 | 24
87 | 3 | 5 | 4 | 0 | 0
(13 rows)
```
**确定查询步骤是否溢出到磁盘**
下面的查询显示查询 ID 为 1025 的查询是否有任何步骤（有关如何获取查询 ID 的信息，请参阅 [SVL\$1QLOG](r_SVL_QLOG.md) 视图）溢出到磁盘，还是查询完全在内存中运行：
```
select query, step, rows, workmem, label, is_diskbased
from svl_query_summary
where query = 1025
order by workmem desc;
```
此查询返回以下示例输出：
```
query| step| rows | workmem | label | is_diskbased
-----+-----+--------+-----------+---------------+--------------
1025 | 0 |16000000| 141557760 |scan tbl=9 | f
1025 | 2 |16000000| 135266304 |hash tbl=142 | t
1025 | 0 |16000000| 128974848 |scan tbl=116536| f
1025 | 2 |16000000| 122683392 |dist | f
(4 rows)
```
通过扫描 IS\$1DISKBASED 的值，您能够了解哪些查询步骤溢出到磁盘。对于查询 1025，哈希步骤在磁盘上运行。可能在磁盘上执行的步骤包括哈希、聚合和排序步骤。要仅查看基于磁盘的查询步骤，请在上面的示例中向 SQL 语句添加 **and is\$1diskbased = 't'** 子句。
# SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS
在经典大小调整期间，使用 SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS 监控集群中每个表迁入 RA3 节点的进度。它捕获调整大小操作期间数据迁移的历史吞吐量。有关 RA3 节点经典大小调整的更多信息，请转到[经典大小调整](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
**注意**
进度为 `100.00%` 或 `ABORTED` 的行将在 7 天后删除。在经典大小调整期间或之后删除的表行仍可显示在 SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS 中。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_RESTORE_ALTER_TABLE_PROGRESS.html)
## 示例查询
以下查询返回了正在运行的查询和已排队的查询。
```
select * from svl_restore_alter_table_progress;
tbl | progress | message
--------+----------+-----------------------------------------------------------
105614 | ABORTED | Abort:Table no longer contains the prior dist key column.
105610 | ABORTED | Abort:Table no longer contains the prior dist key column.
105594 | 0.00% | Table waiting for alter diststyle conversion.
105602 | ABORTED | Abort:Table no longer contains the prior dist key column.
105606 | ABORTED | Abort:Table no longer contains the prior dist key column.
105598 | 100.00% | Restored to distkey successfully.
```
# SVL\$1S3LIST
可以使用 SVL\$1S3LIST 视图获取有关段级别的 Amazon Redshift Spectrum 查询的详细信息。
SVL\$1S3LIST 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
SVL\$1S3LIST 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3LIST.html)
## 示例查询
以下示例查询上次运行的查询的 SVL\$1S3LIST。
```
select *
from svl_s3list
where query = pg_last_query_id()
order by query,segment;
```
# SVL\$1S3LOG
使用 SVL\$1S3LOG 视图获取有关段和节点切片级别的 Amazon Redshift Spectrum 查询的详细信息。
SVL\$1S3LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
SVL\$1S3LOG 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3LOG.html)
## 示例查询
以下示例查询上次运行的查询的 SVL\$1S3LOG。
```
select *
from svl_s3log
where query = pg_last_query_id()
order by query,segment,slice;
```
# SVL\$1S3PARTITION
使用 SVL\$1S3PARTITION 视图可获取有关段和节点切片级别的 Amazon Redshift Spectrum 分区的详细信息。
SVL\$1S3PARTITION 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
SVL\$1S3PARTITION 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3PARTITION.html)
## 示例查询
以下示例获取上次完成的查询的分区详细信息。
```
SELECT query, segment,
MIN(starttime) AS starttime,
MAX(endtime) AS endtime,
datediff(ms,MIN(starttime),MAX(endtime)) AS dur_ms,
MAX(total_partitions) AS total_partitions,
MAX(qualified_partitions) AS qualified_partitions,
MAX(assignment) as assignment_type
FROM svl_s3partition
WHERE query=pg_last_query_id()
GROUP BY query, segment
```
```
query | segment | starttime | endtime | dur_ms| total_partitions | qualified_partitions | assignment_type
------+---------+-------------------------------+-----------------------------+-------+------------------+----------------------+----------------
99232 | 0 | 2018-04-17 22:43:50.201515 | 2018-04-17 22:43:54.674595 | 4473 | 2526 | 334 | p
```
# SVL\$1S3PARTITION\$1SUMMARY
可以使用 SVL\$1S3PARTITION\$1SUMMARY 视图获取段级别的 Redshift Spectrum 查询分区处理摘要。
SVL\$1S3PARTITION\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
有关 SVCS\$1S3PARTITION 的信息，请参阅 [SVCS\$1S3PARTITION\$1SUMMARY](r_SVCS_S3PARTITION_SUMMARY.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3PARTITION_SUMMARY.html)
## 示例查询
以下示例获取上次完成的查询的分区扫描详细信息。
```
select query, segment, assignment, min_starttime, max_endtime, min_duration, avg_duration
from svl_s3partition_summary
where query = pg_last_query_id()
order by query,segment;
```
# SVL\$1S3QUERY
使用 SVL\$1S3QUERY 视图获取有关段和节点切片级别的 Amazon Redshift Spectrum 查询的详细信息。
SVL\$1S3QUERY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
SVL\$1S3QUERY 仅包含在主预置集群上运行的查询。它不包含在并发扩展集群或无服务器命名空间上运行的查询。要访问在主集群、并发扩展集群和无服务器命名空间上运行的查询的解释计划，我们建议您使用 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)。SYS 监控视图中的数据经过格式化处理，便于使用和理解。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3QUERY.html)
## 示例查询
以下示例获取上次完成的查询的扫描步骤详细信息。
```
select query, segment, slice, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files
from svl_s3query
where query = pg_last_query_id()
order by query,segment,slice;
```
```
query | segment | slice | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files
------+---------+-------+---------+-----------------+------------------+-----------------------+------------------------+------
4587 | 2 | 0 | 67811 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 1 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1
4587 | 2 | 2 | 216849 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 3 | 216671 | 0 | 0 | 0 | 0 | 0
```
# SVL\$1S3QUERY\$1SUMMARY
使用 SVL\$1S3QUERY\$1SUMMARY 视图可获取已在系统上运行的所有 Amazon Redshift Spectrum 查询（S3 查询）的汇总。SVL\$1S3QUERY\$1SUMMARY 汇总段级别的 SVL\$1S3QUERY 的详细信息。
SVL\$1S3QUERY\$1SUMMARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
对于 SVCS\$1S3QUERY\$1SUMMARY，请参阅 [SVCS\$1S3QUERY\$1SUMMARY](r_SVCS_S3QUERY_SUMMARY.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3QUERY_SUMMARY.html)
## 示例查询
以下示例获取上次完成的查询的扫描步骤详细信息。
```
select query, segment, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files
from svl_s3query_summary
where query = pg_last_query_id()
order by query,segment;
```
```
query | segment | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files
------+---------+---------+-----------------+------------------+-----------------------+------------------------+------
4587 | 2 | 67811 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1
4587 | 2 | 216849 | 0 | 0 | 0 | 0 | 0
4587 | 2 | 216671 | 0 | 0 | 0 | 0 | 0
```
# SVL\$1S3RETRIES
使用 SVL\$1S3RETRIES 视图获取有关基于 Amazon S3 的 Amazon Redshift Spectrum 查询的失败原因的信息。
SVL\$1S3RETRIES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_S3RETRIES.html)
## 示例查询
下面示例检索有关失败的 S3 查询的数据。
```
SELECT svl_s3retries.query, svl_s3retries.segment, svl_s3retries.node, svl_s3retries.slice, svl_s3retries.eventtime, svl_s3retries.retries,
svl_s3retries.successful_fetches, svl_s3retries.file_size, btrim((svl_s3retries."location")::text) AS "location", btrim((svl_s3retries.message)::text)
AS message FROM svl_s3retries;
```
# SVL\$1SPATIAL\$1SIMPLIFY
您可以查询系统视图 SVL\$1SPATIAL\$1SIMPLIFY，以使用 COPY 命令获取有关简化空间几何对象的信息。在 shapefile 上使用 COPY 时，您可以指定 SIMPLIFY `tolerance`、SIMPLIFY AUTO 和 SIMPLIFY AUTO `max_tolerance` 摄入选项。简化的结果在 SVL\$1SPATIAL\$1SIMPLIFY 系统视图中进行总结。
当设置 SIMPLIFY AUTO `max_tolerance` 时，此视图为每个超出最大大小的几何体都包含一行。当设置 SIMPLIFY `tolerance` 时，则存储整个 COPY 操作的一行。此行引用 COPY 查询 ID 和指定的简化容差。
SVL\$1SPATIAL\$1SIMPLIFY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_SPATIAL_SIMPLIFY.html)
## 示例查询
以下查询返回 COPY 简化的记录的列表。
```
SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
# SVL\$1SPECTRUM\$1SCAN\$1ERROR
您可以查询 SVL\$1SPECTRUM\$1SCAN\$1ERROR 系统视图，以获取有关 Redshift Spectrum 扫描错误的信息。
SVL\$1SPECTRUM\$1SCAN\$1ERROR 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
显示记录的错误示例。每个查询默认显示 10 个条目。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_SPECTRUM_SCAN_ERROR.html)
## 示例查询
以下查询将返回所执行数据处理操作的行列表。
```
SELECT * FROM svl_spectrum_scan_error;
```
该查询返回的结果类似于以下内容。
```
userid query location rowid colname original_value modified_value trigger action action_valueerror_code
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
```
# SVL\$1STATEMENTTEXT
使用 SVL\$1STATEMENTTEXT 视图获取已在系统上运行的所有 SQL 命令的完整记录。
SVL\$1STATEMENTTEXT 视图包含 [STL\$1DDLTEXT](r_STL_DDLTEXT.md)、[STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)、[STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) 表中所有行的联合。此外，此视图还包含到 STL\$1QUERY 表的联接。
SVL\$1STATEMENTTEXT 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_STATEMENTTEXT.html)
## 示例查询
下面的查询返回在 2009 年 6 月 16 日运行的 DDL 语句：
```
select starttime, type, rtrim(text) from svl_statementtext
where starttime like '2009-06-16%' and type='DDL' order by starttime asc;
starttime | type | rtrim
---------------------------|------|--------------------------------
2009-06-16 10:36:50.625097 | DDL | create table ddltest(c1 int);
2009-06-16 15:02:16.006341 | DDL | drop view alltickitjoin;
2009-06-16 15:02:23.65285 | DDL | drop table sales;
2009-06-16 15:02:24.548928 | DDL | drop table listing;
2009-06-16 15:02:25.536655 | DDL | drop table event;
...
```
### 重新构造存储的 SQL
要重新构造存储在 SVL\$1STATEMENTTEXT 的 `text` 列中的 SQL，请运行 SELECT 语句，以从 `text` 列中的一个或多个部分创建 SQL。在运行重新构造的 SQL 之前，将任何 (`\n`) 特殊字符替换为新行。以下 SELECT 语句的结果是 `query_statement` 字段中重新构造的 SQL 的行。
```
select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS query_statement
from SVL_STATEMENTTEXT where pid=pg_backend_pid();
```
例如，以下查询选择 3 列。查询本身超过 200 个字符，并存储在 SVL\$1STATEMENTTEXT 中的多个部分内。
```
select
1 AS a0123456789012345678901234567890123456789012345678901234567890,
2 AS b0123456789012345678901234567890123456789012345678901234567890,
3 AS b012345678901234567890123456789012345678901234
FROM stl_querytext;
```
在此示例中，查询存储在 SVL\$1STATEMENTTEXT 的 `text` 列的 2 个部分（行）中。
```
select sequence, text from SVL_STATEMENTTEXT where pid = pg_backend_pid() order by starttime, sequence;
```
```
sequence | text
----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
0 | select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234
1 | \nFROM stl_querytext;
```
要重新构造存储在 STL\$1STATEMENTTEXT 中的 SQL，请运行以下 SQL。
```
select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS text
from SVL_STATEMENTTEXT where pid=pg_backend_pid();
```
要在客户端中使用生成的重新构造的 SQL，需将任何 (`\n`) 特殊字符替换为新行。
```
text
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234\nFROM stl_querytext;
```
# SVL\$1STORED\$1PROC\$1CALL
您可以查询系统视图 SVL\$1STORED\$1PROC\$1CALL 以获取有关存储过程调用的信息，包括开始时间、结束时间以及是否取消调用。每个存储过程调用接受一个查询 ID。
SVL\$1STORED\$1PROC\$1CALL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_STORED_PROC_CALL.html)
## 示例查询
以下查询按降序顺序返回过去一天中，存储过程调用的用时以及完成状态。
```
select query, datediff(seconds, starttime, endtime) as elapsed_time, aborted, trim(querytxt) as call from svl_stored_proc_call where starttime >= getdate() - interval '1 day' order by 2 desc;
query | elapsed_time | aborted | call
--------+--------------+---------+-----------------------------------------------------------------------------------
4166 | 7 | 0 | call search_batch_status(35,'succeeded');
2433 | 3 | 0 | call test_batch (123456)
1810 | 1 | 0 | call prod_benchmark (123456)
1836 | 1 | 0 | call prod_testing (123456)
1808 | 1 | 0 | call prod_portfolio ('N', 123456)
1816 | 1 | 1 | call prod_portfolio ('Y', 123456)
```
# SVL\$1STORED\$1PROC\$1MESSAGES
您可以查询 SVL\$1STORED\$1PROC\$1MESSAGES 系统视图以获取有关存储过程消息的信息。即使存储过程调用已取消，也会记录引发的消息。每个存储过程调用接受一个查询 ID。有关如何设置记录的消息的最低级别的更多信息，请参阅 stored\$1proc\$1log\$1min\$1messages。
SVL\$1STORED\$1PROC\$1MESSAGES 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_STORED_PROC_MESSAGES.html)
## 示例查询
以下 SQL 语句说明了如何使用 SVL\$1STORED\$1PROC\$1MESSAGES 查看引发的消息。
```
-- Create and run a stored procedure
CREATE OR REPLACE PROCEDURE test_proc1(f1 int) AS
$$
BEGIN
RAISE INFO 'Log Level: Input f1 is %',f1;
RAISE NOTICE 'Notice Level: Input f1 is %',f1;
EXECUTE 'select invalid';
RAISE NOTICE 'Should not print this';
EXCEPTION WHEN OTHERS THEN
raise exception 'EXCEPTION level: Exception Handling';
END;
$$ LANGUAGE plpgsql;
-- Call this stored procedure
CALL test_proc1(2);
-- Show raised messages with level higher than INFO
SELECT query, recordtime, loglevel, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages
WHERE loglevel > 30 AND query = 193 ORDER BY recordtime;
query | recordtime | loglevel | loglevel_text | message | aborted
-------+----------------------------+----------+---------------+-------------------------------------+---------
193 | 2020-03-17 23:57:18.277196 | 40 | NOTICE | Notice Level: Input f1 is 2 | 1
193 | 2020-03-17 23:57:18.277987 | 60 | EXCEPTION | EXCEPTION level: Exception Handling | 1
(2 rows)
-- Show raised messages at EXCEPTION level
SELECT query, recordtime, loglevel, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages
WHERE loglevel_text = 'EXCEPTION' AND query = 193 ORDER BY recordtime;
query | recordtime | loglevel | loglevel_text | message | aborted
-------+----------------------------+----------+---------------+-------------------------------------+---------
193 | 2020-03-17 23:57:18.277987 | 60 | EXCEPTION | EXCEPTION level: Exception Handling | 1
```
以下 SQL 语句说明了在创建存储过程时如何使用 SVL\$1STORED\$1PROC\$1MESSAGES 和 SET 选项查看引发的消息。由于 test\$1proc() 的最低日志级别为 NOTICE，因此，仅在 SVL\$1STORED\$1PROC\$1MESSAGES 中记录 NOTICE、WARNING 和 EXCEPTION 级别消息。
```
-- Create a stored procedure with minimum log level of NOTICE
CREATE OR REPLACE PROCEDURE test_proc() AS
$$
BEGIN
RAISE LOG 'Raise LOG messages';
RAISE INFO 'Raise INFO messages';
RAISE NOTICE 'Raise NOTICE messages';
RAISE WARNING 'Raise WARNING messages';
RAISE EXCEPTION 'Raise EXCEPTION messages';
RAISE WARNING 'Raise WARNING messages again'; -- not reachable
END;
$$ LANGUAGE plpgsql SET stored_proc_log_min_messages = NOTICE;
-- Call this stored procedure
CALL test_proc();
-- Show the raised messages
SELECT query, recordtime, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages
WHERE query = 149 ORDER BY recordtime;
query | recordtime | loglevel_text | message | aborted
-------+----------------------------+---------------+--------------------------+---------
149 | 2020-03-16 21:51:54.847627 | NOTICE | Raise NOTICE messages | 1
149 | 2020-03-16 21:51:54.84766 | WARNING | Raise WARNING messages | 1
149 | 2020-03-16 21:51:54.847668 | EXCEPTION | Raise EXCEPTION messages | 1
(3 rows)
```
# SVL\$1TERMINATE
记录用户取消或终止进程的时间。
SELECT PG\$1TERMINATE\$1BACKEND(*pid*)、SELECT PG\$1CANCEL\$1BACKEND(*pid*) 和 CANCEL *pid* 在 SVL\$1TERMINATE 中创建日志条目。
SVL\$1TERMINATE 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_TERMINATE.html)
以下命令显示最新取消的查询。
```
select * from svl_terminate order by eventtime desc limit 1;
pid | eventtime | userid | type
------+----------------------------+--------+--------
8324 | 2020-03-24 09:42:07.298937 | 1 | CANCEL
(1 row)
```
# SVL\$1UDF\$1LOG
记录在执行用户定义的函数 (UDF) 期间生成的系统定义的错误和警告消息。
SVL\$1UDF\$1LOG 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_UDF_LOG.html)
## 示例查询
以下示例说明 UDF 如何处理系统定义的错误。第一个块显示了返回参数的逆参数的 UDF 函数的定义。在运行函数并提供参数 0 时，如第二个块所示，函数将返回错误。第三个语句将读取在 SVL\$1UDF\$1LOG 中记录的错误消息
```
-- Create a function to find the inverse of a number
CREATE OR REPLACE FUNCTION f_udf_inv(a int)
RETURNS float IMMUTABLE
AS $$
return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with a 0 argument to create an error
Select f_udf_inv(0) from sales;
-- Query SVL_UDF_LOG to view the message
Select query, created, message::varchar
from svl_udf_log;
query | created | message
-------+----------------------------+---------------------------------------------------------
2211 | 2015-08-22 00:11:12.04819 | ZeroDivisionError: long division or modulo by zero\nNone
```
以下示例将日志记录和警告消息添加到 UDF 中，以便被零除运算生成警告消息而不是停止并显示错误消息。
```
-- Create a function to find the inverse of a number and log a warning
CREATE OR REPLACE FUNCTION f_udf_inv_log(a int)
RETURNS float IMMUTABLE
AS $$
import logging
logger = logging.getLogger() #get root logger
if a==0:
logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n')
return 0
else:
return 1/a
$$ LANGUAGE plpythonu;
```
以下示例运行该函数，然后查询 SVL\$1UDF\$1LOG 以查看消息。
```
-- Run the function with a 0 argument to trigger the warning
Select f_udf_inv_log(0) from sales;
-- Query SVL_UDF_LOG to view the message
Select query, created, message::varchar
from svl_udf_log;
query | created | message
------+----------------------------+----------------------------------
0 | 2015-08-22 00:11:12.04819 | You attempted to divide by zero.
Returning zero instead of error.
```
# SVL\$1USER\$1INFO
您可以使用 SVL\$1USER\$1INFO 视图检索有关 Amazon Redshift 数据库用户的数据。
SVL\$1USER\$1INFO 仅对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_USER_INFO.html)
## 示例查询
以下命令从 SVL\$1USER\$1INFO 检索用户信息。
```
SELECT * FROM SVL_USER_INFO;
```
# SVL\$1VACUUM\$1PERCENTAGE
SVL\$1VACUUM\$1PERCENTAGE 视图报告执行 vacuum 操作后为表分配的数据块的百分比。此百分比数字显示回收了多少磁盘空间。有关 vacuum 实用工具的更多信息，请参阅 [VACUUM](r_VACUUM_command.md) 命令。
SVL\$1VACUUM\$1PERCENTAGE 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
此表中的部分或全部数据也可以在 SYS 监控视图 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 监控视图中的数据经过格式化处理，便于使用和理解。我们建议您使用 SYS 监控视图进行查询。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_SVL_VACUUM_PERCENTAGE.html)
## 示例查询
下面的查询显示表 100238 上特定操作的百分比：
```
select * from svl_vacuum_percentage
where table_id=100238 and xid=2200;
xid | table_id | percentage
-----+----------+------------
1337 | 100238 | 60
(1 row)
```
执行此 vacuum 操作后，表包含原始数据块的 60%。
# 系统目录表
**Topics**
+ [PG\$1ATTRIBUTE\$1INFO](r_PG_ATTRIBUTE_INFO.md)
+ [PG\$1CLASS\$1INFO](r_PG_CLASS_INFO.md)
+ [PG\$1DATABASE\$1INFO](r_PG_DATABASE_INFO.md)
+ [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md)
+ [PG\$1EXTERNAL\$1SCHEMA](r_PG_EXTERNAL_SCHEMA.md)
+ [PG\$1LIBRARY](r_PG_LIBRARY.md)
+ [PG\$1PROC\$1INFO](r_PG_PROC_INFO.md)
+ [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md)
+ [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md)
+ [PG\$1USER\$1INFO](pg_user_info.md)
+ [查询目录表](c_join_PG.md)
系统目录存储 schema 元数据，例如，有关表和列的信息。系统目录表具有 PG 前缀。
Amazon Redshift 用户可访问标准 PostgreSQL 目录表。有关 PostgreSQL 系统目录的更多信息，请参阅 [PostgreSQL 系统表](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW)。
# PG\$1ATTRIBUTE\$1INFO
PG\$1ATTRIBUTE\$1INFO 是基于 PostgreSQL 目录表 PG\$1ATTRIBUTE 和内部目录表 PG\$1ATTRIBUTE\$1ACL 构建的 Amazon Redshift 系统视图。PG\$1ATTRIBUTE\$1INFO 包括有关表或视图的列的详细信息，包括列访问控制列表（如果有）。
## 表列
除了 PG\$1ATTRIBUTE 中的列之外，PG\$1ATTRIBUTE\$1INFO 还显示以下列。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html)
# PG\$1CLASS\$1INFO
PG\$1CLASS\$1INFO 是基于 PostgreSQL 目录表 PG\$1CLASS 和 PG\$1CLASS\$1EXTENDED 而构建的 Amazon Redshift 系统视图。PG\$1CLASS\$1INFO 包括有关表创建时间和当前分配方式的详细信息。有关更多信息，请参阅 [用于优化查询的数据分配](t_Distributing_data.md)。
PG\$1CLASS\$1INFO 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
除了 PG\$1CLASS 中的列以外，PG\$1CLASS\$1INFO 还显示以下列。PG\$1CLASS 中的 `oid` 列在 PG\$1CLASS\$1INFO 表中称为 `reloid`。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_CLASS_INFO.html)
PG\$1CLASS\$1INFO 中的 RELEFFECTIVEDISTSTYLE 列指示表的当前分配方式。如果表使用自动分配，则 RELEFFECTIVEDISTSTYLE 为 10、11 或 12，这指示有效分配方式是 AUTO（ALL）、AUTO（EVEN）或 AUTO（KEY）。如果表使用自动分配，则分配方式最初可能显示 AUTO（ALL）。然后，当表增长时更改为 AUTO（EVEN），或者，如果发现某个列可用作分配键，则更改为 AUTO（KEY）。
下表的 RELEFFECTIVEDISTSTYLE 列中提供了每个值的分配方式：
| RELEFFECTIVEDISTSTYLE | 当前分配方式 |
| --- | --- |
| 0 | EVEN |
| 1 | KEY |
| 8 | ALL |
| 10 | AUTO (ALL) |
| 11 | AUTO (EVEN) |
| 12 | AUTO (KEY) |
## 示例
以下查询返回目录中表的当前分配模式。
```
select reloid as tableid,trim(nspname) as schemaname,trim(relname) as tablename,reldiststyle,releffectivediststyle,
CASE WHEN "reldiststyle" = 0 THEN 'EVEN'::text
WHEN "reldiststyle" = 1 THEN 'KEY'::text
WHEN "reldiststyle" = 8 THEN 'ALL'::text
WHEN "releffectivediststyle" = 10 THEN 'AUTO(ALL)'::text
WHEN "releffectivediststyle" = 11 THEN 'AUTO(EVEN)'::text
WHEN "releffectivediststyle" = 12 THEN 'AUTO(KEY)'::text ELSE '<>'::text END as diststyle,relcreationtime
from pg_class_info a left join pg_namespace b on a.relnamespace=b.oid;
```
```
tableid | schemaname | tablename | reldiststyle | releffectivediststyle | diststyle | relcreationtime
---------+------------+-----------+--------------+-----------------------+------------+----------------------------
3638033 | public | customer | 0 | 0 | EVEN | 2019-06-13 15:02:50.666718
3638037 | public | sales | 1 | 1 | KEY | 2019-06-13 15:03:29.595007
3638035 | public | lineitem | 8 | 8 | ALL | 2019-06-13 15:03:01.378538
3638039 | public | product | 9 | 10 | AUTO(ALL) | 2019-06-13 15:03:42.691611
3638041 | public | shipping | 9 | 11 | AUTO(EVEN) | 2019-06-13 15:03:53.69192
3638043 | public | support | 9 | 12 | AUTO(KEY) | 2019-06-13 15:03:59.120695
(6 rows)
```
# PG\$1DATABASE\$1INFO
PG\$1DATABASE\$1INFO 是一个扩展 PostgreSQL 目录表 PG\$1DATABASE 的 Amazon Redshift 系统视图。
PG\$1DATABASE\$1INFO 对所有用户可见。
## 表列
除了 PG\$1DATABASE 中的列之外，PG\$1DATABASE\$1INFO 还包含以下列。PG\$1DATABASE 中的 `oid` 列在 PG\$1DATABASE\$1INFO 表中称为 `datid`。有关更多信息，请参阅 [PostgreSQL 文档](https://www.postgresql.org/docs/8.0/catalog-pg-database.html)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_DATABASE_INFO.html)
# PG\$1DEFAULT\$1ACL
存储有关默认访问权限的信息。有关默认访问权限的更多信息，请参阅 [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)。
PG\$1DEFAULT\$1ACL 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_DEFAULT_ACL.html)
## 示例
以下查询返回为数据库定义的所有默认权限。
```
select pg_get_userbyid(d.defacluser) as user,
n.nspname as schema,
case d.defaclobjtype when 'r' then 'tables' when 'f' then 'functions' end
as object_type,
array_to_string(d.defaclacl, ' + ') as default_privileges
from pg_catalog.pg_default_acl d
left join pg_catalog.pg_namespace n on n.oid = d.defaclnamespace;
user | schema | object_type | default_privileges
-------+--------+-------------+-------------------------------------------------------
admin | tickit | tables | user1=r/admin + "group group1=a/admin" + user2=w/admin
```
上述示例中的结果表明，对于用户 `admin` 在 `tickit` schema 中创建的所有新表，`admin` 将 SELECT 权限授予 `user1`，将 INSERT 权限授予 `group1`，并将 UPDATE 权限授予 `user2`。
# PG\$1EXTERNAL\$1SCHEMA
存储有关外部 schema 的信息。
PG\$1EXTERNAL\$1SCHEMA 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其具有访问权限的元数据。有关更多信息，请参阅 [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_EXTERNAL_SCHEMA.html)
## 示例
以下示例显示有关外部 schema 的详细信息。
```
select esoid, nspname as schemaname, nspowner, esdbname as external_db, esoptions
from pg_namespace a,pg_external_schema b where a.oid=b.esoid;
esoid | schemaname | nspowner | external_db | esoptions
-------+-----------------+----------+-------------+-------------------------------------------------------------
100134 | spectrum_schema | 100 | spectrum_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
100135 | spectrum | 100 | spectrumdb | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
100149 | external | 100 | external_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
```
# PG\$1LIBRARY
存储有关用户定义的库的信息。
PG\$1LIBRARY 对所有用户可见。超级用户可以查看所有行；普通用户只能查看其自己的数据。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_LIBRARY.html)
## 示例
以下示例返回用户安装的库的信息。
```
select * from pg_library;
name | language_oid | file_store_id | owner
-----------+--------------+---------------+------
f_urlparse | 108254 | 2000 | 100
```
# PG\$1PROC\$1INFO
PG\$1PROC\$1INFO 是 Amazon Redshift 系统视图，构建在 PostgreSQL 目录表 PG\$1PROC 和内部目录表 PG\$1PROC\$1EXTENDED 之上。PG\$1PROC\$1INFO 包括有关存储过程和函数的详细信息，这包括与输出参数（如果有）相关的信息。
## 表列
除了 PG\$1PROC 中的列以外，PG\$1PROC\$1INFO 还显示以下列。PG\$1PROC 中的 `oid` 列在 PG\$1PROC\$1INFO 表中称为 `prooid`。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_PROC_INFO.html)
PG\$1PROC\$1INFO 中的 proargnames 字段包含所有类型参数（包含 OUT 和 INOUT，如有）的名称。
# PG\$1STATISTIC\$1INDICATOR
存储有关自上次执行 ANALYZE 以来插入或删除的行数的信息。由于 PG\$1STATISTIC\$1INDICATOR 表在 DML 操作后频繁更新，因此统计数据是近似值。
PG\$1STATISTIC\$1INDICATOR 只对超级用户可见。有关更多信息，请参阅 [系统表和视图中的数据可见性](cm_chap_system-tables.md#c_visibility-of-data)。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_STATISTIC_INDICATOR.html)
## 示例
以下示例返回自上次执行 ANALYZE 以来发生更改的表的信息。
```
select * from pg_statistic_indicator;
stairelid | stairows | staiins | staidels
----------+----------+---------+---------
108271 | 11 | 0 | 0
108275 | 365 | 0 | 0
108278 | 8798 | 0 | 0
108280 | 91865 | 0 | 100632
108267 | 89981 | 49990 | 9999
108269 | 808 | 606 | 374
108282 | 152220 | 76110 | 248566
```
# PG\$1TABLE\$1DEF
存储有关表列的信息。
PG\$1TABLE\$1DEF 仅返回有关对用户可见的表的信息。如果 PG\$1TABLE\$1DEF 未返回预期结果，则验证 [search\$1path](r_search_path.md) 参数是否正确设置为包含相关 schemas。
可使用 [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md) 查看有关表的更多信息，包括数据分配偏斜、密钥分配偏斜、表大小和统计数据。
## 表列
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/r_PG_TABLE_DEF.html)
## 示例
以下示例显示 LINEORDER\$1COMPOUND 表的复合排序键列。
```
select "column", type, encoding, distkey, sortkey, "notnull"
from pg_table_def
where tablename = 'lineorder_compound'
and sortkey <> 0;
column | type | encoding | distkey | sortkey | notnull
-------------+---------+----------+---------+---------+--------
lo_orderkey | integer | delta32k | false | 1 | true
lo_custkey | integer | none | false | 2 | true
lo_partkey | integer | none | true | 3 | true
lo_suppkey | integer | delta32k | false | 4 | true
lo_orderdate | integer | delta | false | 5 | true
(5 rows)
```
以下示例显示 LINEORDER\$1INTERLEAVED 表的交错排序键列。
```
select "column", type, encoding, distkey, sortkey, "notnull"
from pg_table_def
where tablename = 'lineorder_interleaved'
and sortkey <> 0;
column | type | encoding | distkey | sortkey | notnull
-------------+---------+----------+---------+---------+--------
lo_orderkey | integer | delta32k | false | -1 | true
lo_custkey | integer | none | false | 2 | true
lo_partkey | integer | none | true | -3 | true
lo_suppkey | integer | delta32k | false | 4 | true
lo_orderdate | integer | delta | false | -5 | true
(5 rows)
```
PG\$1TABLE\$1DEF 将仅返回搜索路径中包含的 schema 中的表的信息。有关更多信息，请参阅 [search\$1path](r_search_path.md)。
例如，假定您创建一个新 schema 和一个新表，然后查询 PG\$1TABLE\$1DEF。
```
create schema demo;
create table demo.demotable (one int);
select * from pg_table_def where tablename = 'demotable';
schemaname|tablename|column| type | encoding | distkey | sortkey | notnull
----------+---------+------+------+----------+---------+---------+--------
```
此查询未返回新表的行。检查 `search_path` 的设置。
```
show search_path;
search_path
---------------
$user, public
(1 row)
```
将 `demo` 架构添加到搜索路径并重新运行查询。
```
set search_path to '$user', 'public', 'demo';
select * from pg_table_def where tablename = 'demotable';
schemaname| tablename |column| type | encoding |distkey|sortkey| notnull
----------+-----------+------+---------+----------+-------+-------+--------
demo | demotable | one | integer | none | f | 0 | f
(1 row)
```
# PG\$1USER\$1INFO
PG\$1USER\$1INFO 是 Amazon Redshift 系统视图，此视图显示用户信息，例如用户 ID 和密码过期时间。
只有超级用户才能看到 PG\$1USER\$1INFO。
## 表列
PG\$1USER\$1INFO 包含以下列。有关更多信息，请参阅 [PostgreSQL 文档](https://www.postgresql.org/docs/8.0/view-pg-user.html)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_cn/redshift/latest/dg/pg_user_info.html)
# 查询目录表
**Topics**
+ [目录查询示例](c_join_PG_examples.md)
通常，可将目录表和视图（其名称以 **PG\$1** 开头的关系）联接到 Amazon Redshift 表和视图。
目录表使用了 Amazon Redshift 不支持的大量数据类型。当查询将目录表联接到 Amazon Redshift 表时，支持以下数据类型：
+ 布尔
+ "char"
+ float4
+ int2
+ int4
+ int8
+ 名称
+ oid
+ text
+ varchar
如果编写一个显式或隐式引用具有不支持的数据类型的列的联接查询，则该查询将返回一个错误。某些目录表中使用的 SQL 函数也受支持，但 PG\$1SETTINGS 和 PG\$1LOCKS 表使用的 SQL 函数除外。
例如，无法在与 Amazon Redshift 表的联接中查询 PG\$1STATS 表，因为存在不受支持的函数。
以下目录表和视图提供了可联接到 Amazon Redshift 表中的信息的有用信息。由于数据类型和函数限制，其中的一些表仅允许部分访问。在查询可部分访问的表时，请仔细选择或引用其列。
以下表可完全访问且不包含任何不受支持的数据类型或函数：
+ [pg\$1attribute](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html)
+ [pg\$1cast ](https://www.postgresql.org/docs/8.0/static/catalog-pg-cast.html)
+ [pg\$1depend](https://www.postgresql.org/docs/8.0/static/catalog-pg-depend.html)
+ [pg\$1description ](https://www.postgresql.org/docs/8.0/static/catalog-pg-description.html)
+ [pg\$1locks ](https://www.postgresql.org/docs/8.0/static/view-pg-locks.html)
+ [pg\$1opclass ](https://www.postgresql.org/docs/8.0/static/catalog-pg-opclass.html)
以下表可部分访问且包含一些不受支持的类型、函数和已截断的文本列。文本列中的值将截断为 varchar(256) 值。
+ [pg\$1class](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html)
+ [pg\$1constraint](https://www.postgresql.org/docs/8.0/static/catalog-pg-constraint.html)
+ [pg\$1database](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html)
+ [pg\$1group](https://www.postgresql.org/docs/8.0/static/catalog-pg-group.html)
+ [pg\$1language ](https://www.postgresql.org/docs/8.0/static/catalog-pg-language.html)
+ [pg\$1namespace](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html)
+ [pg\$1operator](https://www.postgresql.org/docs/8.0/static/catalog-pg-operator.html)
+ [pg\$1proc](https://www.postgresql.org/docs/8.0/static/catalog-pg-proc.html)
+ [pg\$1settings](https://www.postgresql.org/docs/8.0/static/view-pg-settings.html)
+ [pg\$1statistic](https://www.postgresql.org/docs/8.0/static/catalog-pg-statistic.html)
+ [pg\$1tables](https://www.postgresql.org/docs/8.0/static/view-pg-tables.html)
+ [pg\$1type ](https://www.postgresql.org/docs/8.0/static/catalog-pg-type.html)
+ [pg\$1user](https://www.postgresql.org/docs/8.0/static/view-pg-user.html)
+ [pg\$1views](https://www.postgresql.org/docs/8.0/static/view-pg-views.html)
对于 Amazon Redshift 管理员，此处未列出的目录表是不可访问的或可能没有用。不过，当查询未涉及与 Amazon Redshift 表的联接时，可以查询任何目录表或视图。
可以将 Postgres 目录表中的 OID 列用作联接列。例如，联接条件 `pg_database.oid = stv_tbl_perm.db_id` 将每个 PG\$1DATABASE 行的内部数据库对象 ID 与 STV\$1TBL\$1PERM 表中的可见 DB\$1ID 列匹配。OID 列是内部主键，当您从表中选择时，这些列不可见。目录视图没有 OID 列。
某些 Amazon Redshift 函数必须只在计算节点上运行。如果查询引用用户创建的表，则 SQL 在计算节点上运行。
仅引用目录表（具有 PG 前缀的表（如 PG\$1TABLE\$1DEF））或不引用任何表的查询在领导节点上以独占方式运行。
如果使用计算节点函数的查询不引用用户定义的表，否则 Amazon Redshift 系统表会返回以下错误。
```
[Amazon](500310) Invalid operation: One or more of the used functions must be applied on at least one user created table.
```
# 目录查询示例
以下查询说明了用来查询目录表以获取有关 Amazon Redshift 数据库的有用信息的几种方法。
## 查看表 ID、数据库、架构和表名称
以下视图定义将 STV\$1TBL\$1PERM 系统表与 PG\$1CLASS、PG\$1NAMESPACE 和 PG\$1DATABASE 系统目录表联接以返回表 ID、数据库名称、schema 名称和表名称。
```
create view tables_vw as
select distinct(stv_tbl_perm.id) table_id
,trim(pg_database.datname) db_name
,trim(pg_namespace.nspname) schema_name
,trim(pg_class.relname) table_name
from stv_tbl_perm
join pg_class on pg_class.oid = stv_tbl_perm.id
join pg_namespace on pg_namespace.oid = pg_class.relnamespace
join pg_database on pg_database.oid = stv_tbl_perm.db_id;
```
以下示例返回 ID 为 117855 的表的信息。
```
select * from tables_vw where table_id = 117855;
```
```
table_id | db_name | schema_name | table_name
---------+-----------+-------------+-----------
117855 | dev | public | customer
```
## 列出每个 Amazon Redshift 表的列数
以下查询联接了一些目录表，以了解每个 Amazon Redshift 表包含多少列。Amazon Redshift 表名称存储在 PG\$1TABLES 和 STV\$1TBL\$1PERM 中；如果可能，请使用 PG\$1TABLES 返回 Amazon Redshift 表名称。
此查询不涉及任何 Amazon Redshift 表。
```
select nspname, relname, max(attnum) as num_cols
from pg_attribute a, pg_namespace n, pg_class c
where n.oid = c.relnamespace and a.attrelid = c.oid
and c.relname not like '%pkey'
and n.nspname not like 'pg%'
and n.nspname not like 'information%'
group by 1, 2
order by 1, 2;
nspname | relname | num_cols
--------+----------+----------
public | category | 4
public | date | 8
public | event | 6
public | listing | 8
public | sales | 10
public | users | 18
public | venue | 5
(7 rows)
```
## 列出数据库中的架构和表
以下查询将 STV\$1TBL\$1PERM 联接到一些 PG 表以返回 TICKIT 数据库中的表及其 schema 名称（NSPNAME 列）的列表。该查询还返回每个表中的总行数。（在系统中的多个 schemas 具有相同的表名称时，此查询很有用。）
```
select datname, nspname, relname, sum(rows) as rows
from pg_class, pg_namespace, pg_database, stv_tbl_perm
where pg_namespace.oid = relnamespace
and pg_class.oid = stv_tbl_perm.id
and pg_database.oid = stv_tbl_perm.db_id
and datname ='tickit'
group by datname, nspname, relname
order by datname, nspname, relname;
datname | nspname | relname | rows
--------+---------+----------+--------
tickit | public | category | 11
tickit | public | date | 365
tickit | public | event | 8798
tickit | public | listing | 192497
tickit | public | sales | 172456
tickit | public | users | 49990
tickit | public | venue | 202
(7 rows)
```
## 列出表 ID、数据类型、列名称和表名称
以下查询列出有关每个用户表及其列的一些信息：表 ID、表名称、表列名称和每个列的数据类型：
```
select distinct attrelid, rtrim(name), attname, typname
from pg_attribute a, pg_type t, stv_tbl_perm p
where t.oid=a.atttypid and a.attrelid=p.id
and a.attrelid between 100100 and 110000
and typname not in('oid','xid','tid','cid')
order by a.attrelid asc, typname, attname;
attrelid | rtrim | attname | typname
---------+----------+----------------+-----------
100133 | users | likebroadway | bool
100133 | users | likeclassical | bool
100133 | users | likeconcerts | bool
...
100137 | venue | venuestate | bpchar
100137 | venue | venueid | int2
100137 | venue | venueseats | int4
100137 | venue | venuecity | varchar
...
```
## 计算表中的每个列的数据块数
以下查询将 STV\$1BLOCKLIST 表联接到 PG\$1CLASS 以返回 SALES 表中列的存储信息。
```
select col, count(*)
from stv_blocklist s, pg_class p
where s.tbl=p.oid and relname='sales'
group by col
order by col;
col | count
----+-------
0 | 4
1 | 4
2 | 4
3 | 4
4 | 4
5 | 4
6 | 4
7 | 4
8 | 4
9 | 8
10 | 4
12 | 4
13 | 8
(13 rows)
```