从补丁 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/)。
# 系统监控（仅已预置）
可以在已预置集群上查询以下系统表和视图。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%。