Amazon Redshift 將不再支援從修補程式 198 開始建立新的 Python UDFs。現有 Python UDF 將繼續正常運作至 2026 年 6 月 30 日。如需詳細資訊，請參閱[部落格文章](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)。
本文為英文版的機器翻譯版本，如內容有任何歧義或不一致之處，概以英文版為準。
# 系統資料表和檢視參考
Amazon Redshift 具有許多系統資料表和檢視，其中包含系統如何運作的相關資訊。您可以使用查詢任何其他資料庫資料表的方式，來查詢這些系統資料表和檢視。本節示範一些系統資料表查詢的例子並說明：
+ 系統如何產生不同類型的資料表和檢視
+ 您可以從這些資料表取得什麼類型的資訊
+ 如何將 Amazon Redshift 系統資料表聯結至目錄資料表
+ 如何管理不斷增多的系統資料表日誌檔案
有些系統資料表只能供 AWS 員工用於診斷目的。以下章節討論系統管理員或其他資料庫使用者可以查詢實用資訊的系統資料表。
**注意**
自動或手動叢集備份 (快照) 不包括系統資料表。STL 系統檢視會保留 7 天的日誌歷史記錄。保留日誌不需要客戶執行任何動作，但如果您想要儲存日誌資料超過 7 天，則必須定期將其複製到其他資料表或卸載到 Amazon S3。
**Topics**
+ [
## 系統資料表和檢視的類型
](#c_types-of-system-tables-and-views)
+ [
## 系統資料表和檢視中資料的可見性
](#c_visibility-of-data)
+ [
## 將僅佈建的查詢移轉至 SYS 監控檢視查詢
](#sys_view_migration-use_cases)
+ [
## 使用 SYS 監控檢視改善查詢識別碼追蹤
](#sys_view_migration-query-id)
+ [
## 系統資料表查詢、程序和工作階段 ID
](#system-table-query-process-session-ids)
+ [
# SVV 中繼資料檢視
](svv_views.md)
+ [
# SYS 監控檢視
](serverless_views-monitoring.md)
+ [
# 移轉至 SYS 監控檢視的系統檢視映射
](sys_view_migration.md)
+ [
# 系統監控 (僅限已佈建)
](c_intro_system_views.md)
+ [
# 系統目錄資料表
](c_intro_catalog_views.md)
## 系統資料表和檢視的類型
系統資料表和檢視有以下幾種類型：
+ SVV 檢視包含有關資料庫物件的資訊，以及對暫時性 STV 資料表的參考。
+ SYS 檢視可用來監控已佈建叢集和無伺服器工作群組的查詢和工作負載使用情況。
+ STL 檢視是從已經保存到磁碟的日誌所產生，提供系統的歷史記錄。
+ STV 資料表是虛擬系統資料表，包含目前系統資料的快照。他們是建基於暫時性記憶體內資料，而不會保存到磁碟型日誌或一般資料表。
+ SVCS 檢視可提供主要叢集與並行擴展叢集查詢的詳細資訊。
+ SVL 檢視提供有關主要叢集上查詢的詳細資料。
系統資料表和檢視不會使用相同的一致性模型做為一般資料表。因此查詢這些資料表和檢視時需要注意此問題，特別是查詢 STV 資料表和 SVV 檢視時。例如一般資料表 t1 (包含欄 c1)，預期以下查詢不會傳回任何列：
```
select * from t1
where c1 > (select max(c1) from t1)
```
但是以下對系統資料表的查詢可能會傳回列：
```
select * from stv_exec_state
where currenttime > (select max(currenttime) from stv_exec_state)
```
此查詢可能會傳回列的原因是 currenttime 為暫時性，而查詢中的兩個參考在評估時可能不會傳回相同的值。
另一方面，下列查詢可能不會傳回任何列：
```
select * from stv_exec_state
where currenttime = (select max(currenttime) from stv_exec_state)
```
## 系統資料表和檢視中資料的可見性
**注意**
Amazon Redshift 會在記錄對 Data Catalog 檢視進行之查詢的相關資訊時，自動遮罩特定系統資料表欄，以防止暴露敏感的中繼資料。如需詳細資訊，請參閱《Amazon Redshift 管理指南》**中的[安全記錄](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing-secure-logging.html)。
系統資料表和檢視中資料的可見性分為兩個類別：使用者可查看和超級使用者可查看。
擁有超級使用者權限的使用者才可以查看「超級使用者可查看」類別裡資料表的資料。一般使用者可以查看「使用者可查看」資料表裡的資料。若要讓一般使用者存取超級使用者可查看的資料表，請將該資料表的 SELECT 權限授予一般使用者。如需詳細資訊，請參閱[GRANT](r_GRANT.md)。
依預設，在大部份「使用者可查看」資料表中，一般使用者無法查看另一位使用者產生的列。如果一般使用者獲得 [SYSLOG ACCESS UNRESTRICTED](r_ALTER_USER.md#alter-user-syslog-access)，該使用者就可以查看使用者可查看的資料表中的所有列，包括另一位使用者產生的列。如需詳細資訊，請參閱 [ALTER USER](r_ALTER_USER.md) 或 [CREATE USER](r_CREATE_USER.md) 。所有使用者皆可看到 SVV\$1TRANSACTIONS 中的所有列。如需資料可見性的詳細資訊，請參閱 AWS re:Post 知識庫文章[如何允許 Amazon Redshift 資料庫一般使用者檢視來自其他叢集使用者之系統資料表中的資料？](https://repost.aws/knowledge-center/amazon-redshift-system-tables)。
對於中繼資料檢視，Amazon Redshift 不允許具有 SYSLOG ACCESS UNRESTRICTED 許可的使用者查看。
**注意**
若使用者擁有不受限制的系統資料表存取權限，該使用者就能查看其他使用者產生的資料。例如，STL\$1QUERY 和 STL\$1QUERY\$1TEXT 包含 INSERT、UPDATE 和 DELETE 陳述式的全文，當中可能包含使用者產生的敏感資料。
超級使用者可以查看所有資料表中的所有列。若要讓一般使用者存取「超級使用者可查看」資料表，請在該資料表上將 SELECT 權限授予 [GRANT](r_GRANT.md) 一般使用者。
### 篩選系統產生的查詢
查詢相關的系統資料表和檢視，例如 SVL\$1QUERY\$1SUMMARY、SVL\$1QLOG 等等，通常包含大量自動產生的陳述式，Amazon Redshift 會使用這些陳述式來監控資料庫的狀態。超級使用者可以看到這些系統產生的查詢，但這些查詢通常作用不大。從使用 `userid` 欄的系統資料表或系統檢視選取時，若要把這些查詢篩選掉，請在 WHERE 子句新增 `userid > 1` 條件。例如：
```
select * from svl_query_summary where userid > 1
```
## 將僅佈建的查詢移轉至 SYS 監控檢視查詢
### 從已佈建的叢集遷移至 Amazon Redshift Serverless
如果您要將佈建叢集移轉到 Amazon Redshift Serverless，則可能會使用下列系統檢視進行查詢，這些檢視只會儲存來自佈建叢集的資料。
+ 所有 STL 檢視
+ 所有 STV 檢視
+ 所有 SVCS 檢視
+ 所有 SVL 檢視
+ 一些 SVV 檢視
+ 如需 Amazon Redshift Serverless 中不支援的 SVV 檢視的完整清單，請參閱《Amazon Redshift 管理指南》**中的[使用 Amazon Redshift Serverless 監控查詢和工作負載](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-monitoring.html)底部的清單。
若要繼續使用您的查詢，請重新調整這些查詢，使其使用 SYS 監控檢視中定義的資料欄，這些欄對應於僅供佈建檢視中的欄。若要查看僅限佈建檢視與 SYS 監控檢視之間的映射關係，請前往 [移轉至 SYS 監控檢視的系統檢視映射](sys_view_migration.md)
### 停留在已佈建叢集的同時更新查詢
如果您不是遷移到 Amazon Redshift Serverless，您可能仍想要更新現有的查詢。SYS 監控檢視的設計目的是易於使用和降低複雜性，提供完整的指標陣列以進行有效的監控和疑難排解。使用 SYS 檢視 (例如 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 和 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) ) 合併多個僅供佈建檢視的資訊，您可以簡化查詢。
## 使用 SYS 監控檢視改善查詢識別碼追蹤
SYS 監控檢視 (例如 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 和 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)) 包含 query\$1id 欄，該欄保存使用者查詢的識別碼。同樣地，僅供佈建的檢視 (例如 [STL\$1QUERY](r_STL_QUERY.md) 和 [SVL\$1QLOG](r_SVL_QLOG.md)) 包含查詢欄，此欄也包含查詢識別碼。不過，SYS 系統檢視中記錄的查詢識別碼與僅供佈建檢視中記錄的查詢識別碼不同。
SYS 檢視表的 query\$1id 欄值與僅供佈建檢視的查詢欄值之間的差異如下：
+ 在 SYS 檢視中，query\$1id 欄會以其原始形式記錄使用者提交的查詢。Amazon Redshift 最佳化工具可能會將它們分解為子查詢以提高效能，但是您執行的單一查詢在 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) 中仍只有一列。如果您想查看個別子查詢，可以在[SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)中找到它們。
+ 在僅佈建的檢視中，查詢欄會記錄子查詢層級的查詢。如果 Amazon Redshift 最佳化工具將您的原始查詢重寫為多個子查詢，對於您執行的單一查詢，[STL\$1QUERY](r_STL_QUERY.md) 中將有多列具有不同的查詢識別碼值。
當您將監控和診斷查詢從僅佈建檢視移轉至 SYS 檢視時，請考慮此差異，然後相應地編輯您的查詢。如需 Amazon Redshift 如何處理查詢的相關資訊，請參閱[查詢計劃和執行工作流程](c-query-planning.md)。
### 範例
如需 Amazon Redshift 如何在僅限佈建和 SYS 監控檢視中以不同的方式記錄查詢的範例，請參閱下列範例查詢。這是按照您在 Amazon Redshift 中執行的方式所編寫的查詢。
```
SELECT
s_name
, COUNT(*) AS numwait
FROM
supplier,
lineitem l1,
orders,
nation
WHERE s_suppkey = l1.l_suppkey
AND o_orderkey = l1.l_orderkey
AND o_orderstatus = 'F'
AND l1.l_receiptdate > l1.l_commitdate
AND EXISTS (SELECT
*
FROM
lineitem l2
WHERE l2.l_orderkey = l1.l_orderkey
AND l2.l_suppkey <> l1.l_suppkey )
AND NOT EXISTS (SELECT
*
FROM
lineitem l3
WHERE l3.l_orderkey = l1.l_orderkey
AND l3.l_suppkey <> l1.l_suppkey
AND l3.l_receiptdate > l3.l_commitdate )
AND s_nationkey = n_nationkey
AND n_name = 'UNITED STATES'
GROUP BY
s_name
ORDER BY
numwait DESC
, s_name LIMIT 100;
```
在此之下，Amazon Redshift 查詢最佳化工具會將上述使用者提交的查詢重寫為 5 個子查詢。
第一個子查詢建立一個暫存資料表來實現一個子查詢。
```
CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey
, l_suppkey
, s_name ) AS SELECT
l1.l_orderkey
, l1.l_suppkey
, public.supplier.s_name
FROM
public.lineitem AS l1,
public.nation,
public.orders,
public.supplier
WHERE l1.l_commitdate < l1.l_receiptdate
AND l1.l_orderkey = public.orders.o_orderkey
AND l1.l_suppkey = public.supplier.s_suppkey
AND public.nation.n_name = 'UNITED STATES'::CHAR(8)
AND public.nation.n_nationkey = public.supplier.s_nationkey
AND public.orders.o_orderstatus = 'F'::CHAR(1);
```
第二個子查詢會從暫存資料表收集統計資料。
```
padb_fetch_sample: select count(*) from volt_tt_606590308b512;
```
第三個子查詢建立另一個暫存資料表來具體化另一個子查詢，引用上面建立的暫存資料表。
```
CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey
, l_suppkey) AS (SELECT
volt_tt_606590308b512.l_orderkey
, volt_tt_606590308b512.l_suppkey
FROM
public.lineitem AS l2,
volt_tt_606590308b512
WHERE l2.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l2.l_orderkey = volt_tt_606590308b512.l_orderkey)
EXCEPT distinct (SELECT volt_tt_606590308b512.l_orderkey, volt_tt_606590308b512.l_suppkey
FROM public.lineitem AS l3, volt_tt_606590308b512
WHERE l3.l_commitdate < l3.l_receiptdate
AND l3.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l3.l_orderkey = volt_tt_606590308b512.l_orderkey);
```
第四個子查詢再次收集暫存資料表的統計資料。
```
padb_fetch_sample: select count(*) from volt_tt_606590308c2ef
```
最後一個子查詢使用上面建立的暫存資料表來產生輸出。
```
SELECT
volt_tt_606590308b512.s_name AS s_name
, COUNT(*) AS numwait
FROM
volt_tt_606590308b512,
volt_tt_606590308c2ef
WHERE volt_tt_606590308b512.l_orderkey = volt_tt_606590308c2ef.l_orderkey
AND volt_tt_606590308b512.l_suppkey = volt_tt_606590308c2ef.l_suppkey
GROUP BY
1
ORDER BY
2 DESC
, 1 ASC LIMIT 100;
```
在僅佈建的系統檢視 STL\$1QUERY 中，Amazon Redshift 會在子查詢層級記錄五個資料列，如下所示：
```
SELECT userid, xid, pid, query, querytxt::varchar(100);
FROM stl_query
WHERE xid = 48237350
ORDER BY xid, starttime;
userid | xid | pid | query | querytxt
--------+----------+------------+----------+------------------------------------------------------------------------------------------------------
101 | 48237350 | 1073840810 | 12058151 | CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey, l_suppkey, s_name) AS SELECT l1.l_orderkey, l1.l
101 | 48237350 | 1073840810 | 12058152 | padb_fetch_sample: select count(*) from volt_tt_606590308b512
101 | 48237350 | 1073840810 | 12058156 | CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey, l_suppkey) AS (SELECT volt_tt_606590308b512.l_or
101 | 48237350 | 1073840810 | 12058168 | padb_fetch_sample: select count(*) from volt_tt_606590308c2ef
101 | 48237350 | 1073840810 | 12058170 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.
(5 rows)
```
在 SYS 監控檢視 SYS\$1QUERY\$1HISTORY 中，Amazon Redshift 會記錄查詢，如下所示：
```
SELECT user_id, transaction_id, session_id, query_id, query_text::varchar(100)
FROM sys_query_history
WHERE transaction_id = 48237350
ORDER BY start_time;
user_id | transaction_id | session_id | query_id | query_text
---------+----------------+------------+----------+------------------------------------------------------------------------------------------------------
101 | 48237350 | 1073840810 | 12058149 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.
```
在 SYS\$1QUERY\$1DETAIL 中，您可以使用來自 SYS\$1QUERY\$1HISTORY 的 query\$1id 值來尋找子項查詢層級的詳細資訊。child\$1query\$1sequence 欄顯示子查詢的執行順序。如需 SYS\$1QUERY\$1DETAIL 中欄的相關資訊，請參閱[SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)。
```
select user_id,
query_id,
child_query_sequence,
stream_id,
segment_id,
step_id,
start_time,
end_time,
duration,
blocks_read,
blocks_write,
local_read_io,
remote_read_io,
data_skewness,
time_skewness,
is_active,
spilled_block_local_disk,
spilled_block_remote_disk
from sys_query_detail
where query_id = 12058149
and step_id = -1
order by query_id,
child_query_sequence,
stream_id,
segment_id,
step_id;
user_id | query_id | child_query_sequence | stream_id | segment_id | step_id | start_time | end_time | duration | blocks_read | blocks_write | local_read_io | remote_read_io | data_skewness | time_skewness | is_active | spilled_block_local_disk | spilled_block_remote_disk
---------+----------+----------------------+-----------+------------+---------+----------------------------+----------------------------+----------+-------------+--------------+---------------+----------------+---------------+---------------+-----------+--------------------------+---------------------------
101 | 12058149 | 1 | 0 | 0 | -1 | 2023-09-27 15:40:38.512415 | 2023-09-27 15:40:38.533333 | 20918 | 0 | 0 | 0 | 0 | 0 | 44 | f | 0 | 0
101 | 12058149 | 1 | 1 | 1 | -1 | 2023-09-27 15:40:39.931437 | 2023-09-27 15:40:39.972826 | 41389 | 12 | 0 | 12 | 0 | 0 | 77 | f | 0 | 0
101 | 12058149 | 1 | 2 | 2 | -1 | 2023-09-27 15:40:40.584412 | 2023-09-27 15:40:40.613982 | 29570 | 32 | 0 | 32 | 0 | 0 | 25 | f | 0 | 0
101 | 12058149 | 1 | 2 | 3 | -1 | 2023-09-27 15:40:40.582038 | 2023-09-27 15:40:40.615758 | 33720 | 0 | 0 | 0 | 0 | 0 | 1 | f | 0 | 0
101 | 12058149 | 1 | 3 | 4 | -1 | 2023-09-27 15:40:46.668766 | 2023-09-27 15:40:46.705456 | 36690 | 24 | 0 | 15 | 0 | 0 | 17 | f | 0 | 0
101 | 12058149 | 1 | 4 | 5 | -1 | 2023-09-27 15:40:46.707209 | 2023-09-27 15:40:46.709176 | 1967 | 0 | 0 | 0 | 0 | 0 | 18 | f | 0 | 0
101 | 12058149 | 1 | 4 | 6 | -1 | 2023-09-27 15:40:46.70656 | 2023-09-27 15:40:46.71289 | 6330 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 1 | 5 | 7 | -1 | 2023-09-27 15:40:46.71405 | 2023-09-27 15:40:46.714343 | 293 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 2 | 0 | 0 | -1 | 2023-09-27 15:40:52.083907 | 2023-09-27 15:40:52.087854 | 3947 | 0 | 0 | 0 | 0 | 0 | 35 | f | 0 | 0
101 | 12058149 | 2 | 1 | 1 | -1 | 2023-09-27 15:40:52.089632 | 2023-09-27 15:40:52.091129 | 1497 | 0 | 0 | 0 | 0 | 0 | 11 | f | 0 | 0
101 | 12058149 | 2 | 1 | 2 | -1 | 2023-09-27 15:40:52.089008 | 2023-09-27 15:40:52.091306 | 2298 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 3 | 0 | 0 | -1 | 2023-09-27 15:40:56.882013 | 2023-09-27 15:40:56.897282 | 15269 | 0 | 0 | 0 | 0 | 0 | 29 | f | 0 | 0
101 | 12058149 | 3 | 1 | 1 | -1 | 2023-09-27 15:40:59.718554 | 2023-09-27 15:40:59.722789 | 4235 | 0 | 0 | 0 | 0 | 0 | 13 | f | 0 | 0
101 | 12058149 | 3 | 2 | 2 | -1 | 2023-09-27 15:40:59.800382 | 2023-09-27 15:40:59.807388 | 7006 | 0 | 0 | 0 | 0 | 0 | 58 | f | 0 | 0
101 | 12058149 | 3 | 3 | 3 | -1 | 2023-09-27 15:41:06.488685 | 2023-09-27 15:41:06.493825 | 5140 | 0 | 0 | 0 | 0 | 0 | 56 | f | 0 | 0
101 | 12058149 | 3 | 3 | 4 | -1 | 2023-09-27 15:41:06.486206 | 2023-09-27 15:41:06.497756 | 11550 | 0 | 0 | 0 | 0 | 0 | 2 | f | 0 | 0
101 | 12058149 | 3 | 4 | 5 | -1 | 2023-09-27 15:41:06.499201 | 2023-09-27 15:41:06.500851 | 1650 | 0 | 0 | 0 | 0 | 0 | 15 | f | 0 | 0
101 | 12058149 | 3 | 4 | 6 | -1 | 2023-09-27 15:41:06.498609 | 2023-09-27 15:41:06.500949 | 2340 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 3 | 5 | 7 | -1 | 2023-09-27 15:41:06.502945 | 2023-09-27 15:41:06.503282 | 337 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 4 | 0 | 0 | -1 | 2023-09-27 15:41:06.62899 | 2023-09-27 15:41:06.631452 | 2462 | 0 | 0 | 0 | 0 | 0 | 22 | f | 0 | 0
101 | 12058149 | 4 | 1 | 1 | -1 | 2023-09-27 15:41:06.632313 | 2023-09-27 15:41:06.63391 | 1597 | 0 | 0 | 0 | 0 | 0 | 20 | f | 0 | 0
101 | 12058149 | 4 | 1 | 2 | -1 | 2023-09-27 15:41:06.631726 | 2023-09-27 15:41:06.633813 | 2087 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
101 | 12058149 | 5 | 0 | 0 | -1 | 2023-09-27 15:41:12.571974 | 2023-09-27 15:41:12.584234 | 12260 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0
101 | 12058149 | 5 | 0 | 1 | -1 | 2023-09-27 15:41:12.569815 | 2023-09-27 15:41:12.585391 | 15576 | 0 | 0 | 0 | 0 | 0 | 4 | f | 0 | 0
101 | 12058149 | 5 | 1 | 2 | -1 | 2023-09-27 15:41:13.758513 | 2023-09-27 15:41:13.76401 | 5497 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0
101 | 12058149 | 5 | 1 | 3 | -1 | 2023-09-27 15:41:13.749 | 2023-09-27 15:41:13.772987 | 23987 | 0 | 0 | 0 | 0 | 0 | 32 | f | 0 | 0
101 | 12058149 | 5 | 2 | 4 | -1 | 2023-09-27 15:41:13.799526 | 2023-09-27 15:41:13.813506 | 13980 | 0 | 0 | 0 | 0 | 0 | 62 | f | 0 | 0
101 | 12058149 | 5 | 2 | 5 | -1 | 2023-09-27 15:41:13.798823 | 2023-09-27 15:41:13.813651 | 14828 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0
(28 rows)
```
## 系統資料表查詢、程序和工作階段 ID
分析系統資料表中出現的查詢、程序和工作階段 ID 時，請注意下列事項：
+ 查詢 ID 值 (在 `query_id` 和 `query` 等欄中) 可以隨著時間重複使用。
+ 程序 ID 或工作階段 ID 值 (在 `process_id`、`pid` 和 `session_id` 等欄中) 可以隨著時間重複使用。
+ 交易 ID 值 (在 `transaction_id` 和 `xid` 等欄中) 是唯一的。
# SVV 中繼資料檢視
SVV 檢視是 Amazon Redshift 中的系統檢視，其中包含資料庫物件的相關資訊。請注意，雖然它們會儲存使用者許可或資料表名稱等資訊，但主要不是用於聯結使用者建立的關係。
**注意**
如果資料庫回應因任何原因而失敗，Amazon Redshift 會報告 WARNING，而非ERROR。當您在資料共用中查詢物件時，Amazon Redshift 不會傳送 ERROR 訊息。
**Topics**
+ [
# SVV\$1ACTIVE\$1CURSORS
](r_SVV_ACTIVE_CURSORS.md)
+ [
# SVV\$1ALL\$1COLUMNS
](r_SVV_ALL_COLUMNS.md)
+ [
# SVV\$1ALL\$1SCHEMAS
](r_SVV_ALL_SCHEMAS.md)
+ [
# SVV\$1ALL\$1TABLES
](r_SVV_ALL_TABLES.md)
+ [
# SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS
](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md)
+ [
# SVV\$1ATTACHED\$1MASKING\$1POLICY
](r_SVV_ATTACHED_MASKING_POLICY.md)
+ [
# SVV\$1COLUMNS
](r_SVV_COLUMNS.md)
+ [
# SVV\$1COLUMN\$1PRIVILEGES
](r_SVV_COLUMN_PRIVILEGES.md)
+ [
# SVV\$1COPY\$1JOB\$1INTEGRATIONS
](SVV_COPY_JOB_INTEGRATIONS.md)
+ [
# SVV\$1DATABASE\$1PRIVILEGES
](r_SVV_DATABASE_PRIVILEGES.md)
+ [
# SVV\$1DATASHARE\$1PRIVILEGES
](r_SVV_DATASHARE_PRIVILEGES.md)
+ [
# SVV\$1DATASHARES
](r_SVV_DATASHARES.md)
+ [
# SVV\$1DATASHARE\$1CONSUMERS
](r_SVV_DATASHARE_CONSUMERS.md)
+ [
# SVV\$1DATASHARE\$1OBJECTS
](r_SVV_DATASHARE_OBJECTS.md)
+ [
# SVV\$1DEFAULT\$1PRIVILEGES
](r_SVV_DEFAULT_PRIVILEGES.md)
+ [
# SVV\$1DISKUSAGE
](r_SVV_DISKUSAGE.md)
+ [
# SVV\$1EXTERNAL\$1COLUMNS
](r_SVV_EXTERNAL_COLUMNS.md)
+ [
# SVV\$1EXTERNAL\$1DATABASES
](r_SVV_EXTERNAL_DATABASES.md)
+ [
# SVV\$1EXTERNAL\$1PARTITIONS
](r_SVV_EXTERNAL_PARTITIONS.md)
+ [
# SVV\$1EXTERNAL\$1SCHEMAS
](r_SVV_EXTERNAL_SCHEMAS.md)
+ [
# SVV\$1EXTERNAL\$1TABLES
](r_SVV_EXTERNAL_TABLES.md)
+ [
# SVV\$1FUNCTION\$1PRIVILEGES
](r_SVV_FUNCTION_PRIVILEGES.md)
+ [
# SVV\$1GEOGRAPHY\$1COLUMNS
](r_SVV_GEOGRAPHY_COLUMNS.md)
+ [
# SVV\$1GEOMETRY\$1COLUMNS
](r_SVV_GEOMETRY_COLUMNS.md)
+ [
# SVV\$1IAM\$1PRIVILEGES
](r_SVV_IAM_PRIVILEGES.md)
+ [
# SVV\$1IDENTITY\$1PROVIDERS
](r_SVV_IDENTITY_PROVIDERS.md)
+ [
# SVV\$1INTEGRATION
](r_SVV_INTEGRATION.md)
+ [
# SVV\$1INTEGRATION\$1TABLE\$1MAPPING
](r_SVV_INTEGRATION_TABLE_MAPPING.md)
+ [
# SVV\$1INTEGRATION\$1TABLE\$1STATE
](r_SVV_INTEGRATION_TABLE_STATE.md)
+ [
# SVV\$1INTERLEAVED\$1COLUMNS
](r_SVV_INTERLEAVED_COLUMNS.md)
+ [
# SVV\$1LANGUAGE\$1PRIVILEGES
](r_SVV_LANUGAGE_PRIVILEGES.md)
+ [
# SVV\$1MASKING\$1POLICY
](r_SVV_MASKING_POLICY.md)
+ [
# SVV\$1ML\$1MODEL\$1INFO
](r_SVV_ML_MODEL_INFO.md)
+ [
# SVV\$1ML\$1MODEL\$1PRIVILEGES
](r_SVV_ML_MODEL_PRIVILEGES.md)
+ [
# SVV\$1MV\$1DEPENDENCY
](r_SVV_MV_DEPENDENCY.md)
+ [
# SVV\$1MV\$1INFO
](r_SVV_MV_INFO.md)
+ [
# SVV\$1QUERY\$1INFLIGHT
](r_SVV_QUERY_INFLIGHT.md)
+ [
# SVV\$1QUERY\$1STATE
](r_SVV_QUERY_STATE.md)
+ [
# SVV\$1REDSHIFT\$1COLUMNS
](r_SVV_REDSHIFT_COLUMNS.md)
+ [
# SVV\$1REDSHIFT\$1DATABASES
](r_SVV_REDSHIFT_DATABASES.md)
+ [
# SVV\$1REDSHIFT\$1FUNCTIONS
](r_SVV_REDSHIFT_FUNCTIONS.md)
+ [
# SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA
](r_SVV_REDSHIFT_SCHEMA_QUOTA.md)
+ [
# SVV\$1REDSHIFT\$1SCHEMAS
](r_SVV_REDSHIFT_SCHEMAS.md)
+ [
# SVV\$1REDSHIFT\$1TABLES
](r_SVV_REDSHIFT_TABLES.md)
+ [
# SVV\$1RELATION\$1PRIVILEGES
](r_SVV_RELATION_PRIVILEGES.md)
+ [
# SVV\$1RLS\$1APPLIED\$1POLICY
](r_SVV_RLS_APPLIED_POLICY.md)
+ [
# SVV\$1RLS\$1ATTACHED\$1POLICY
](r_SVV_RLS_ATTACHED_POLICY.md)
+ [
# SVV\$1RLS\$1POLICY
](r_SVV_RLS_POLICY.md)
+ [
# SVV\$1RLS\$1RELATION
](r_SVV_RLS_RELATION.md)
+ [
# SVV\$1ROLE\$1GRANTS
](r_SVV_ROLE_GRANTS.md)
+ [
# SVV\$1ROLES
](r_SVV_ROLES.md)
+ [
# SVV\$1SCHEMA\$1PRIVILEGES
](r_SVV_SCHEMA_PRIVILEGES.md)
+ [
# SVV\$1SCHEMA\$1QUOTA\$1STATE
](r_SVV_SCHEMA_QUOTA_STATE.md)
+ [
# SVV\$1SYSTEM\$1PRIVILEGES
](r_SVV_SYSTEM_PRIVILEGES.md)
+ [
# SVV\$1TABLE\$1INFO
](r_SVV_TABLE_INFO.md)
+ [
# SVV\$1TABLES
](r_SVV_TABLES.md)
+ [
# SVV\$1TRANSACTIONS
](r_SVV_TRANSACTIONS.md)
+ [
# SVV\$1USER\$1GRANTS
](r_SVV_USER_GRANTS.md)
+ [
# SVV\$1USER\$1INFO
](r_SVV_USER_INFO.md)
+ [
# SVV\$1VACUUM\$1PROGRESS
](r_SVV_VACUUM_PROGRESS.md)
+ [
# SVV\$1VACUUM\$1SUMMARY
](r_SVV_VACUUM_SUMMARY.md)
# SVV\$1ACTIVE\$1CURSORS
SVV\$1ACTIVE\$1CURSORS 顯示目前開啟之游標的詳細資訊。如需詳細資訊，請參閱[DECLARE](declare.md)。
所有使用者都可看見 SVV\$1ACTIVE\$1CURSORS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。使用者只能檢視該使用者所開啟的游標。超級使用者可檢視所有游標。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ACTIVE_CURSORS.html)
# SVV\$1ALL\$1COLUMNS
使用 SVV\$1ALL\$1COLUMNS 可檢視來自 Amazon Redshift 資料表的欄聯集，如 SVV\$1REDSHIFT\$1COLUMNS 所示，以及所有外部資料表中所有外部欄的合併清單。如需 Amazon Redshift 欄的相關資訊，請參閱[SVV\$1REDSHIFT\$1COLUMNS](r_SVV_REDSHIFT_COLUMNS.md)。
所有使用者都可看見 SVV\$1ALL\$1COLUMNS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ALL_COLUMNS.html)
## 範例查詢
下列範例會傳回 SVV\$1ALL\$1COLUMNS 的輸出。
```
SELECT *
FROM svv_all_columns
WHERE database_name = 'tickit_db'
AND TABLE_NAME = 'tickit_sales_redshift'
ORDER BY COLUMN_NAME,
SCHEMA_NAME
LIMIT 5;
database_name | schema_name | table_name | column_name | ordinal_position | column_default | is_nullable | data_type | character_maximum_length | numeric_precision | numeric_scale | remarks
--------------+-------------+-----------------------+-------------+------------------+----------------+-------------+-----------+--------------------------+-------------------+---------------+---------
tickit_db | public | tickit_sales_redshift | buyerid | 4 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | commission | 9 | | YES | numeric | | 8 | 2 |
tickit_db | public | tickit_sales_redshift | dateid | 7 | | NO | smallint | | 16 | 0 |
tickit_db | public | tickit_sales_redshift | eventid | 5 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | listid | 2 | | NO | integer | | 32 | 0 |
```
# SVV\$1ALL\$1SCHEMAS
使用 SVV\$1ALL\$1SCHEMA 來檢視 Amazon Redshift 結構描述的聯集，如 SVV\$1REDSHIFT\$1SCHEMAS 所示，以及所有資料庫中所有外部結構描述的合併清單。如需 Amazon Redshift 結構描述的相關資訊，請參閱[SVV\$1REDSHIFT\$1SCHEMAS](r_SVV_REDSHIFT_SCHEMAS.md)。
所有使用者都可看見 SVV\$1ALL\$1SCHEMAS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ALL_SCHEMAS.html)
## 範例查詢
下列範例會傳回 SVV\$1ALL\$1SCHEMAS 的輸出。
```
SELECT *
FROM svv_all_schemas
WHERE database_name = 'tickit_db'
ORDER BY database_name,
SCHEMA_NAME;
database_name | schema_name | schema_owner | schema_type | schema_acl | source_database | schema_option
---------------+--------------------+--------------+-------------+------------+-----------------+---------------
tickit_db | public | 1 | shared | | |
```
# SVV\$1ALL\$1TABLES
使用 SVV\$1ALL\$1TABLES 來檢視 Amazon Redshift 資料表的聯集，如 SVV\$1REDSHIFT\$1TABLES 所示，以及來自所有外部結構描述之所有外部資料表的合併清單。如需有關 Amazon Redshift 資料表的資訊，請參閱[SVV\$1REDSHIFT\$1TABLES](r_SVV_REDSHIFT_TABLES.md)。
所有使用者都可看見 SVV\$1ALL\$1TABLES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ALL_TABLES.html)
## 範例查詢
下列範例會傳回 SVV\$1ALL\$1TABLES 的輸出。
```
SELECT *
FROM svv_all_tables
WHERE database_name = 'tickit_db'
ORDER BY TABLE_NAME,
SCHEMA_NAME
LIMIT 5;
database_name | schema_name | table_name | table_type | table_acl | remarks
---------------+-------------+--------------------------+------------+-----------+---------
tickit_db | public | tickit_category_redshift | TABLE | |
tickit_db | public | tickit_date_redshift | TABLE | |
tickit_db | public | tickit_event_redshift | TABLE | |
tickit_db | public | tickit_listing_redshift | TABLE | |
tickit_db | public | tickit_sales_redshift | TABLE | |
```
如果 table\$1acl 值為 null，表示沒有明確授予對應資料表的存取權限。
# SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS
記錄資料表目前的 Amazon Redshift Advisor 建議。此檢視會顯示所有資料表的建議，不論這些資料表是否定義為自動最佳化。若要檢視資料表是否已定義為自動最佳化，請參閱[SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md)。項目只會針對目前工作階段資料庫中可見的資料表而顯示。在套用建議之後 (無論是由 Amazon Redshift 或您執行)，該建議將不再出現在檢視中。
只有超級使用者才能看到 SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ALTER_TABLE_RECOMMENDATIONS.html)
## 範例查詢
在下列範例中，結果中的列會顯示分散索引鍵和排序索引鍵的建議。這些列也會顯示建議是否符合 Amazon Redshift 自動套用的資格。
```
select type, database, table_id, group_id, ddl, auto_eligible
from svv_alter_table_recommendations;
```
```
type | database | table_id | group_id | ddl | auto_eligible
diststyle | db0 | 117884 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f
diststyle | db0 | 117892 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f
diststyle | db0 | 117885 | 1 | ALTER TABLE "sch"."catalog_returns" ALTER DISTSTYLE KEY DISTKEY "cr_sold_date_sk", ALTER COMPOUND SORTKEY ("cr_sold_date_sk","cr_returned_time_sk") | t
sortkey | db0 | 117890 | -1 | ALTER TABLE "sch"."customer_addresses" ALTER COMPOUND SORTKEY ("ca_address_sk") | t
```
# SVV\$1ATTACHED\$1MASKING\$1POLICY
使用 SVV\$1ATTACHED\$1MASKING\$1POLICY 可檢視目前連線資料庫上連接政策的所有關係和角色/使用者。
只有超級使用者和具有 [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) 角色的使用者才能檢視 SVV\$1ATTACHED\$1MASKING\$1POLICY。一般使用者將看到 0 列。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ATTACHED_MASKING_POLICY.html)
## 內部函數
SVV\$1ATTACHED\$1MASKING\$1POLICY 支援以下內部功能：
### mask\$1get\$1policy\$1for\$1role\$1on\$1column
取得套用至指定欄/角色配對的最高優先順序政策。
#### 語法
```
mask_get_policy_for_role_on_column
(relschema,
relname,
colname,
rolename);
```
#### Parameters
*relschema*
政策所在之結構描述的名稱。
*relname*
政策所在的資料表的名稱。
*colname*
連接政策之欄的名稱。
*rolename*
政策連接的角色的名稱。
### mask\$1get\$1policy\$1for\$1user\$1on\$1column
取得套用至指定欄/使用者配對的最高優先順序政策。
#### 語法
```
mask_get_policy_for_user_on_column
(relschema,
relname,
colname,
username);
```
#### Parameters
*relschema*
政策所在之結構描述的名稱。
*relname*
政策所在的資料表的名稱。
*colname*
連接政策之欄的名稱。
*rolename*
政策連接的使用者名稱。
# SVV\$1COLUMNS
使用 SVV\$1COLUMNS 來檢視本機和外部資料表和檢視之欄位的相關資訊 (包含[近期繫結的檢視](r_CREATE_VIEW.md#r_CREATE_VIEW_late-binding-views))。
根據預設，所有使用者都可看見 SVV\$1COLUMNS。若要控制對資料庫中繼資料的存取，請為您的佈建叢集或無伺服器工作群組啟用中繼資料安全。中繼資料安全可讓您依使用者和角色區分物件中繼資料的檢視許可。如需詳細資訊，請參閱[中繼資料安全性](t_metadata_security.md)。
SVV\$1COLUMNS 檢視會繫結來自 [系統目錄資料表](c_intro_catalog_views.md) (字首為 PG 的資料表) 和 [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md) 系統畫面的資料表中繼資料。此系統目錄會說明 Amazon Redshift 資料庫資料表。SVV\$1EXTERNAL\$1COLUMNS 會說明與 Amazon Redshift Spectrum 一同使用的外部資料表。
所有使用者可以查看系統目錄資料表中的所有列。一般使用者僅能夠看見他們獲授權可存取之外部資料表的 SVV\$1EXTERNAL\$1COLUMNS 檢視之欄定義。雖然一般使用者可以看見系統目錄資料表中的資料表中繼資料，如果他們擁有該資料表，或獲授予存取權，他們只能夠從使用者定義的資料表選取資料。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_COLUMNS.html)
# SVV\$1COLUMN\$1PRIVILEGES
使用 SVV\$1COLUMN\$1PRIVILEGES 可檢視明確授予目前資料庫中使用者、角色和群組的欄許可。
下列使用者可以看見 SVV\$1COLUMN\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_COLUMN_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1COLUMN\$1PRIVILEGES 的結果。
```
SELECT namespace_name,relation_name,COLUMN_NAME,privilege_type,identity_name,identity_type
FROM svv_column_privileges WHERE relation_name = 'lineitem';
namespace_name | relation_name | column_name | privilege_type | identity_name | identity_type
----------------+---------------+-------------+----------------+---------------+----------------
public | lineitem | l_orderkey | SELECT | reguser | user
public | lineitem | l_orderkey | SELECT | role1 | role
public | lineitem | l_partkey | SELECT | reguser | user
public | lineitem | l_partkey | SELECT | role1 | role
```
# SVV\$1COPY\$1JOB\$1INTEGRATIONS
使用 SVV\$1COPY\$1JOB\$1INTEGRATIONS 來檢視 S3 事件整合的詳細資訊。
此檢視包含已建立的 S3 事件整合。
所有使用者都可看見 SVV\$1COPY\$1JOB\$1INTEGRATIONS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SVV_COPY_JOB_INTEGRATIONS.html)
下列範例會傳回目前資料庫的 S3 整合。
```
SELECT * FROM SVV_COPY_JOB_INTEGRATIONS WHERE db_name = pg_catalog.current_database();
```
# SVV\$1DATABASE\$1PRIVILEGES
使用 SVV\$1DATABASE\$1PRIVILEGES 來檢視明確授予給 Amazon Redshift 叢集中的使用者、角色和群組的資料庫許可。
下列使用者可以看見 SVV\$1DATABASE\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DATABASE_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1DATABASE\$1PRIVILEGES 的結果。
```
SELECT database_name,privilege_type,identity_name,identity_type,admin_option FROM svv_database_privileges
WHERE database_name = 'test_db';
database_name | privilege_type | identity_name | identity_type | admin_option
---------------+----------------+---------------+---------------+--------------
test_db | CREATE | reguser | user | False
test_db | CREATE | role1 | role | False
test_db | TEMP | public | public | False
test_db | TEMP | role1 | role | False
```
# SVV\$1DATASHARE\$1PRIVILEGES
使用 SVV\$1DATASHARE\$1PRIVILEGES 來檢視明確授予給 Amazon Redshift 叢集中的使用者、角色和群組的資料共用許可。
下列使用者可以看見 SVV\$1DATASHARE\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DATASHARE_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1DATASHARE\$1PRIVILEGES 的結果。
```
SELECT datashare_name,privilege_type,identity_name,identity_type,admin_option FROM svv_datashare_privileges
WHERE datashare_name = 'demo_share';
datashare_name | privilege_type | identity_name | identity_type | admin_option
----------------+----------------+----------------+---------------+--------------
demo_share | ALTER | superuser | user | False
demo_share | ALTER | reguser | user | False
```
# SVV\$1DATASHARES
使用 SVV\$1DATASHARES 來檢視在叢集上建立的資料共用清單，以及與叢集共用的資料共用。
下列使用者可以看見 SVV\$1DATASHARES：
+ 超級使用者
+ 資料共用擁有者
+ 對資料共用具有 ALTER 或 USAGE 許可的使用者
其他使用者看不到任何列。如需 ALTER 和 USAGE 許可的詳細資訊，請參閱[GRANT](r_GRANT.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DATASHARES.html)
## 使用須知
**擷取其他中繼資料** - 您可以使用 `share_owner` 欄中傳回的整數，在 [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md) 中使用 `usesysid` 進行聯結，以取得資料共用擁有者的相關資料。這包括名稱和其他屬性。
## 範例查詢
下列範例會傳回 SVV\$1DATASHARES 的輸出。
```
SELECT share_owner, source_database, share_type, is_publicaccessible
FROM svv_datashares
WHERE share_name LIKE 'tickit_datashare%'
AND source_database = 'dev';
share_owner | source_database | share_type | is_publicaccessible
--------------+-----------------+-------------+----------------------
100 | dev | OUTBOUND | True
(1 rows)
```
下列範例會傳回傳出資料共用之 SVV\$1DATASHARES 的輸出。
```
SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'OUTBOUND';
share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account| producer_namespace | managed_by
----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+-----------------+--------------------------------------+------------
salesshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
marketingshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
```
下列範例會傳回傳入資料共用之 SVV\$1DATASHARES 的輸出。
```
SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'INBOUND';
share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account | producer_namespace | managed_by
----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+------------------+--------------------------------------+------------
salesshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
marketingshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | ADX
```
# SVV\$1DATASHARE\$1CONSUMERS
使用 SVV\$1DATASHARE\$1CONSUMERS 來檢視叢集上建立之資料共用的消費者清單。
下列使用者可以看見 SVV\$1DATASHARE\$1CONSUMERS：
+ 超級使用者
+ 資料共用擁有者
+ 對資料共用具有 ALTER 或 USAGE 許可的使用者
其他使用者看不到任何列。如需 ALTER 和 USAGE 許可的詳細資訊，請參閱[GRANT](r_GRANT.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DATASHARE_CONSUMERS.html)
## 範例查詢
下列範例會傳回 SVV\$1DATASHARE\$1CONSUMERS 的輸出。
```
SELECT count(*)
FROM svv_datashare_consumers
WHERE share_name LIKE 'tickit_datashare%';
1
```
# SVV\$1DATASHARE\$1OBJECTS
使用 SVV\$1DATASHARE\$1OBJECTS 可檢視叢集上建立或與叢集共用之所有資料共用中的物件清單。
所有使用者都可看見 SVV\$1DATASHARE\$1OBJECTS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
如需有關檢視資料共用清單的詳細資訊，請參閱 [SVV\$1DATASHARES](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_DATASHARES.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DATASHARE_OBJECTS.html)
## 範例查詢
下列範例會傳回 SVV\$1DATASHARE\$1OBJECTS 的輸出。
```
SELECT share_type,
btrim(share_name)::varchar(16) AS share_name,
object_type,
object_name
FROM svv_datashare_objects
WHERE share_name LIKE 'tickit_datashare%'
AND object_name LIKE '%tickit%'
ORDER BY object_name
LIMIT 5;
share_type | share_name | object_type | object_name
------------+--------------------+-------------+---------------------------------
OUTBOUND | tickit_datashare | table | public.tickit_category_redshift
OUTBOUND | tickit_datashare | table | public.tickit_date_redshift
OUTBOUND | tickit_datashare | table | public.tickit_event_redshift
OUTBOUND | tickit_datashare | table | public.tickit_listing_redshift
OUTBOUND | tickit_datashare | table | public.tickit_sales_redshift
```
```
SELECT * FROM SVV_DATASHARE_OBJECTS WHERE share_name like 'sales%';
share_type | share_name | object_type | object_name | producer_account | producer_namespace | include_new
-----------+------------+-------------+--------------+------------------+--------------------------------------+-------------
OUTBOUND | salesshare | schema | public | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | t
OUTBOUND | salesshare | table | public.sales | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d |
```
# SVV\$1DEFAULT\$1PRIVILEGES
使用 SVV\$1DEFAULT\$1PRIVILEGES 可檢視使用者在 Amazon Redshift 叢集中可存取的預設權限。
下列使用者可以看見 SVV\$1DEFAULT\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到授予他們的預設許可。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DEFAULT_PRIVILEGES.html)
## 範例查詢
下列範例會傳回 SVV\$1DEFAULT\$1PRIVILEGES 的輸出。
```
SELECT * from svv_default_privileges;
schema_name | object_type | owner_id | owner_name | owner_type | privilege_type | grantee_id | grantee_name | grantee_type | admin_option
-------------+-------------------+--------- +------------+------------+----------------+------------+--------------+--------------+-------------+
public | RELATION | 106 | u1 | user | UPDATE | 107 | u2 | user | f |
public | RELATION | 106 | u1 | user | SELECT | 107 | u2 | user | f |
```
# SVV\$1DISKUSAGE
Amazon Redshift 透過繫結 STV\$1TBL\$1PERM 和 STV\$1BLOCKLIST 資料表來建立 SVV\$1DISKUSAGE 系統畫面。SVV\$1DISKUSAGE 檢視包含資料庫中該資料表之資料分配的相關資訊。
使用彙總查詢與 SVV\$1DISKUSAGE (如下範例所示) 以判斷每個資料庫、資料表、分割或欄位所配置的磁碟區塊數。每個資料區塊都使用 1 MB。您也可以使用 [STV\$1PARTITIONS](r_STV_PARTITIONS.md) 來檢視磁碟使用率的摘要資訊。
只有超級使用者才能看到 SVV\$1DISKUSAGE。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_DISKUSAGE.html)
## 範例查詢
SVV\$1DISKUSAGE 在每個配置的磁碟區塊上包含一個資料列，因此選取所有資料列的查詢可能會傳回數量非常大的資料列。建議僅適用彙總查詢搭配 SVV\$1DISKUSAGE。
傳回於 USERS 資料表中欄位 6 (EMAIL 欄位) 配置的區塊數上限：
```
select db_id, trim(name) as tablename, max(blocknum)
from svv_diskusage
where name='users' and col=6
group by db_id, name;
db_id | tablename | max
--------+-----------+-----
175857 | users | 2
(1 row)
```
下列查詢會為名為 SALESNEW 的大型 10 個欄位的資料表中所有欄位傳回類似結果。(欄位 10 到 12 的最後三列會供隱藏的中繼資料欄位使用。)
```
select db_id, trim(name) as tablename, col, tbl, max(blocknum)
from svv_diskusage
where name='salesnew'
group by db_id, name, col, tbl
order by db_id, name, col, tbl;
db_id | tablename | col | tbl | max
--------+------------+-----+--------+-----
175857 | salesnew | 0 | 187605 | 154
175857 | salesnew | 1 | 187605 | 154
175857 | salesnew | 2 | 187605 | 154
175857 | salesnew | 3 | 187605 | 154
175857 | salesnew | 4 | 187605 | 154
175857 | salesnew | 5 | 187605 | 79
175857 | salesnew | 6 | 187605 | 79
175857 | salesnew | 7 | 187605 | 302
175857 | salesnew | 8 | 187605 | 302
175857 | salesnew | 9 | 187605 | 302
175857 | salesnew | 10 | 187605 | 3
175857 | salesnew | 11 | 187605 | 2
175857 | salesnew | 12 | 187605 | 296
(13 rows)
```
# SVV\$1EXTERNAL\$1COLUMNS
使用 SVV\$1EXTERNAL\$1COLUMNS 來檢視外部資料表中欄位的詳細資訊。也可以使用 SVV\$1EXTERNAL\$1COLUMNS 進行跨資料庫查詢，以檢視使用者有權存取的未連線資料庫上的資料表中所有欄的詳細資訊。
所有使用者都可看見 SVV\$1EXTERNAL\$1COLUMNS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_EXTERNAL_COLUMNS.html)
# SVV\$1EXTERNAL\$1DATABASES
使用 SVV\$1EXTERNAL\$1DATABASES 來檢視外部資料庫的詳細資訊。
所有使用者都可看見 SVV\$1EXTERNAL\$1DATABASES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_EXTERNAL_DATABASES.html)
# SVV\$1EXTERNAL\$1PARTITIONS
使用 SVV\$1EXTERNAL\$1PARTITIONS 來檢視外部資料表中分割區的詳細資訊。
所有使用者都可看見 SVV\$1EXTERNAL\$1PARTITIONS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱 [系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_EXTERNAL_PARTITIONS.html)
# SVV\$1EXTERNAL\$1SCHEMAS
使用 SVV\$1EXTERNAL\$1SCHEMAS 來檢視外部結構描述的相關資訊。如需詳細資訊，請參閱[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。
所有使用者都可看見 SVV\$1EXTERNAL\$1SCHEMAS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_EXTERNAL_SCHEMAS.html)
## 範例
下列範例顯示外部結構描述的詳細資訊。
```
select * from svv_external_schemas;
esoid | eskind | schemaname | esowner | databasename | esoptions
-------+--------+------------+---------+--------------+-------------------------------------------------------------
100133 | 1 | spectrum | 100 | redshift | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
```
# SVV\$1EXTERNAL\$1TABLES
使用 SVV\$1EXTERNAL\$1TABLES 檢視外部資料表的詳細資訊；如需詳細資訊，請參閱 [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。也可以使用 SVV\$1EXTERNAL\$1TABLES 進行跨資料庫查詢，以檢視使用者有權存取的未連線資料庫上所有資料表的中繼資料。
所有使用者都可看見 SVV\$1EXTERNAL\$1TABLES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_EXTERNAL_TABLES.html)
## 範例
下列範例顯示詳細資料 svv\$1external\$1tables，其具有聯合查詢所使用之外部結構描述上的述詞。
```
select schemaname, tablename from svv_external_tables where schemaname = 'apg_tpch';
schemaname | tablename
------------+-----------
apg_tpch | customer
apg_tpch | lineitem
apg_tpch | nation
apg_tpch | orders
apg_tpch | part
apg_tpch | partsupp
apg_tpch | region
apg_tpch | supplier
(8 rows)
```
# SVV\$1FUNCTION\$1PRIVILEGES
使用 SVV\$1FUNCTION\$1PRIVILEGES 來檢視明確授予目前資料庫中使用者、角色和群組的函數許可。
下列使用者可以看見 SVV\$1FUNCTION\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_FUNCTION_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1FUNCTION\$1PRIVILEGES 的結果。
```
SELECT namespace_name,function_name,argument_types,privilege_type,identity_name,identity_type,admin_option FROM svv_function_privileges
WHERE identity_name IN ('role1', 'reguser');
namespace_name | function_name | argument_types | privilege_type | identity_name | identity_type | admin_option
----------------+---------------+----------------------------+----------------+----------------+---------------+--------------
public | test_func1 | integer | EXECUTE | role1 | role | False
public | test_func2 | integer, character varying | EXECUTE | reguser | user | False
```
# SVV\$1GEOGRAPHY\$1COLUMNS
使用 SVV\$1GEOGRAPHY\$1COLUMNS 來檢視資料倉儲中 GEOGRAPHY 欄的清單。此欄清單包含來自資料共用的欄。
所有使用者都可看見 SVV\$1GEOGRAPHY\$1COLUMNS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_GEOGRAPHY_COLUMNS.html)
## 範例查詢
下列範例顯示 SVV\$1GEOGRAPHY\$1COLUMNS 的結果。
```
SELECT * FROM svv_geography_columns;
f_table_catalog | f_table_schema | f_table_name | f_geography_column | coord_dimension | srid | type
-----------------+-----------------+---------------+---------------------+-----------------+------+--------------
dev | public | spatial_test | test_geography | 2 | 0 | GEOGRAPHY
```
# SVV\$1GEOMETRY\$1COLUMNS
使用 SVV\$1GEOMETRY\$1COLUMNS 可檢視資料倉儲中的 GEOMETRY 欄清單。此欄清單包含來自資料共用的欄。
所有使用者都可看見 SVV\$1GEOMETRY\$1COLUMNS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_GEOMETRY_COLUMNS.html)
## 範例查詢
下列範例顯示 SVV\$1GEOMETRY\$1COLUMNS 的結果。
```
SELECT * FROM svv_geometry_columns;
f_table_catalog | f_table_schema | f_table_name | f_geometry_column | coord_dimension | srid | type
-----------------+-----------------+---------------+---------------------+-----------------+------+--------------
dev | public | accomodations | shape | 2 | 0 | GEOMETRY
dev | public | zipcode | wkb_geometry | 2 | 0 | GEOMETRY
```
# SVV\$1IAM\$1PRIVILEGES
使用 SVV\$1IAM\$1PRIVILEGES 可檢視明確授予使用者、角色和群組的 IAM 權限。
下列使用者可以看見 SVV\$1IAM\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取的項目。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_IAM_PRIVILEGES.html)
## 範例查詢
以下範例顯示 SVV\$1IAM\$1PRIVILEGES 的結果。
```
SELECT * from SVV_IAM_PRIVILEGES ORDER BY IDENTITY_ID;
iam_arn | command_type | identity_id | identity_name | identity_type
----------------------+--------------+-------------+---------------+---------------
default-aws-iam-role | COPY | 0 | public | public
default-aws-iam-role | UNLOAD | 0 | public | public
default-aws-iam-role | CREATE MODEL | 0 | public | public
default-aws-iam-role | EXFUNC | 0 | public | public
default-aws-iam-role | COPY | 106 | u1 | user
default-aws-iam-role | UNLOAD | 106 | u1 | user
default-aws-iam-role | CREATE MODEL | 106 | u1 | user
default-aws-iam-role | EXFUNC | 106 | u1 | user
default-aws-iam-role | COPY | 118413 | r1 | role
default-aws-iam-role | UNLOAD | 118413 | r1 | role
default-aws-iam-role | CREATE MODEL | 118413 | r1 | role
default-aws-iam-role | EXFUNC | 118413 | r1 | role
(12 rows)
```
# SVV\$1IDENTITY\$1PROVIDERS
SVV\$1IDENTITY\$1PROVIDERS 檢視會傳回身分提供者的名稱和其他屬性。如需如何建立身分提供者的相關資訊，請參閱[CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md)。
只有超級使用者才能看到 SVV\$1IDENTITY\$1PROVIDERS。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_IDENTITY_PROVIDERS.html)
### 範例查詢
若要檢視身分提供者內容，請在建立身分提供者之後執行如下查詢。
```
SELECT name, type, instanceid, namespc, params, enabled
FROM svv_identity_providers
ORDER BY 1;
```
範例輸出包含 Microsoft Entra ID （先前稱為 Azure AD) 的參數描述：
```
name | type | instanceid | namespc | params | enabled
------------------+-------+--------------------------------------+---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+---------
rs5517_azure_idp | azure | e40d4bb2-7670-44ae-bfb8-5db013221d73 | abc | {"issuer":"https://login.microsoftonline.com/e40d4bb2-7670-44ae-bfb8-5db013221d73/v2.0", "client_id":"871c010f-5e61-4fb1-83ac-98610a7e9110", "client_secret":, "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift", "https://analysis.windows.net/powerbi/connector/AWSRDS"]} | t
(1 row)
```
範例輸出包含以下參數描述 AWS IAM Identity Center：
```
name | type | instanceid | namespc | params | enabled
----------+--------+------------------------------------------------------------------------------------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+---------
idc_name | awsidc | arn:aws:sso::123456789012:application/ssoins-12345f67fe123d4/apl-a0b0a12dc123b1a4 | idc_namespc | {"iam_role":"arn:aws:iam::123456789012:role/MyRedshiftRole","instance_arn":"arn:aws:sso:::instance/ssoins-12345f67fe123d4","is_lakehouse_app":"true"} | t
(1 row)
```
# SVV\$1INTEGRATION
SVV\$1INTEGRATION 會顯示整合組態的詳細資訊。
只有超級使用者才能看到 SVV\$1INTEGRATION。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
如需零 ETL 整合的相關資訊，請參閱[零 ETL 整合](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_INTEGRATION.html)
## 範例查詢
下列 SQL 指令會顯示目前定義的整合。
```
select * from svv_integration;
integration_id | target_database | source | state | current_lag | last_replicated_checkpoint | total_tables_replicated | total_tables_failed | creation_time | refresh_interval | source_database | is_history_mode
---------------------------------------+-----------------+--------+-----------------+-------------+-------------------------------------+-------------------------+---------------------+---------------------------+--------------------+-----------------+-----------------
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | MySQL | CdcRefreshState | 56606106 | {"txn_seq":9834,"txn_id":126597515} | 152 | 0 | 2023-09-19 21:05:27.520299| 720 + mysourceetl | f
```
# SVV\$1INTEGRATION\$1TABLE\$1MAPPING
當這些欄位的識別碼值不同時，SVV\$1INTEGRATION\$1TABLE\$1MAPPING 會顯示來源資料庫、結構描述、資料表、欄和資料類型與目標之間的映射。
**注意**
此檢視只會針對下列類型的零 ETL 整合填入：
AWS Glue Amazon SageMaker Lakehouse 的第三方應用程式
Amazon DynamoDB 至 Amazon SageMaker 資料湖倉
如需詳細資訊，請參閱《AWS Glue 開發人員指南》**中的[零 ETL 整合](https://docs.aws.amazon.com/glue/latest/dg/zero-etl-using.html)。
從來源到目標的識別碼值轉換遵循下列規則：
+ 大寫字母會轉換為小寫。
+ 非小寫字母、數字或底線 (\$1) 的字元會轉換為底線 (\$1)。
+ 如果與現有識別碼值發生衝突，則新的識別碼會附加通用唯一識別碼 (UUID)。
+ 如果來源識別碼值是 Amazon Redshift 關鍵字，則新的識別碼會附加字尾 `_redshift`。
轉換後，字元必須是小寫字母、數字或底線 (\$1)，並符合規則運算式模式 `[a-z0-9_]`。下列範例示範轉換規則：
| 來源 | Target | 備註 |
| --- | --- | --- |
| foo | foo | 無轉換 |
| 長條圖 | bar | |
| fooBar | foobar | |
| foo1 | foo1 | 無轉換 |
| foo\$11 | foo\$11 | 無轉換 |
| Bar@1 | bar\$11 | |
| foo\$1bar@ | foo\$1bar\$1 | |
| 案例 | case\$1redshift | |
所有使用者都可看見 SVV\$1INTEGRATION\$1TABLE\$1MAPPING。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
如需零 ETL 整合的詳細資訊，請參閱《Amazon Redshift 管理指南》**中的[零 ETL 整合](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_MAPPING.html)
## 範例查詢
下列 SQL 命令會顯示從來源到目標的中繼資料值映射。
```
select * from svv_integration_table_mapping;
integration_id | source_database | target_database | source_schema_name | target_schema_name | source_table_name | target_table_name |
---------------------------------------+-----------------+-----------------+---------------------+--------------------+---------------------------------------+
99108e72-1cfd-414f-8cc0-0216acefac77 | mydatabase | mydatabase | myschema | myschema | Mytable | mytable |
| source_column_name | target_column_name | source_data_type | target_data_type |
+--------------------+--------------------+-------------------+------------------+
| Mycolumnname | mycolumnname | Mydatatype | mydatatype |
```
# SVV\$1INTEGRATION\$1TABLE\$1STATE
SVV\$1INTEGRATION\$1TABLE\$1STATE 會顯示資料表層級整合資訊的詳細資料。
只有超級使用者才能看到 SVV\$1INTEGRATION\$1TABLE\$1STATE。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
如需詳細資訊，請參閱[零 ETL 整合](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html)
## 範例查詢
下列 SQL 命令會顯示整合日誌的欄。
```
select * from svv_integration_table_state;
integration_id | target_database | schema_name | table_name | table_state |table_last_replicated_checkpoint | reason | last_updated_timestamp |table_rows | table_size | is_history_mode
--------------------------------------+-----------------+-------------+-------------------+--------------+---------------------------------+--------+----------------------------+------------+------------+-----------------
4798e675-8f9f-4686-b05f-92c538e19629 | sample_test2 | sample | SampleTestChannel | Synced | {"txn_seq":3,"txn_id":3122} | | 2023-05-12 12:40:30.656625 | 2 | 16 | f
```
# SVV\$1INTERLEAVED\$1COLUMNS
使用 SVV\$1INTERLEAVED\$1COLUMNS 檢視來協助判斷是否應使用 [VACUUM REINDEX](r_VACUUM_command.md#vacuum-reindex)，為使用交錯排序索引鍵的資料表重新建立索引。如需如何判斷執行 VACUUM 的頻率與執行 VACUUM REINDEX 的時間之相關資訊，請參閱[盡可能縮短清空時間](vacuum-managing-vacuum-times.md)。
只有超級使用者才能看到 SVV\$1INTERLEAVED\$1COLUMNS。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_INTERLEAVED_COLUMNS.html)
## 範例查詢
若要識別可能需要重新建立索引的資料表，請執行下列查詢。
```
select tbl as tbl_id, stv_tbl_perm.name as table_name,
col, interleaved_skew, last_reindex
from svv_interleaved_columns, stv_tbl_perm
where svv_interleaved_columns.tbl = stv_tbl_perm.id
and interleaved_skew is not null;
tbl_id | table_name | col | interleaved_skew | last_reindex
--------+------------+-----+------------------+--------------------
100068 | lineorder | 0 | 3.65 | 2015-04-22 22:05:45
100068 | lineorder | 1 | 2.65 | 2015-04-22 22:05:45
100072 | customer | 0 | 1.65 | 2015-04-22 22:05:45
100072 | lineorder | 1 | 1.00 | 2015-04-22 22:05:45
(4 rows)
```
# SVV\$1LANGUAGE\$1PRIVILEGES
使用 SVV\$1LANGUAGE\$1PRIVILEGES 來檢視明確授予目前資料庫中的使用者、角色和群組的語言許可。
下列使用者可以看見 SVV\$1LANGUAGE\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_LANUGAGE_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1LANGUAGE\$1PRIVILEGES 的結果。
```
SELECT language_name,privilege_type,identity_name,identity_type,admin_option FROM svv_language_privileges
WHERE identity_name IN ('role1', 'reguser');
language_name | privilege_type | identity_name | identity_type | admin_option
---------------+----------------+---------------+---------------+---------------
exfunc | USAGE | reguser | user | False
exfunc | USAGE | role1 | role | False
plpythonu | USAGE | reguser | user | False
```
# SVV\$1MASKING\$1POLICY
使用 SVV\$1MASKING\$1POLICY 來檢視在叢集上建立的所有遮罩政策。
只有超級使用者和具有 [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) 角色的使用者才能檢視 SVV\$1MASKING\$1POLICY。一般使用者將看到 0 列。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_MASKING_POLICY.html)
# SVV\$1ML\$1MODEL\$1INFO
關於機器學習模型目前狀態的狀態資訊。
所有使用者都可看見 SVV\$1ML\$1MODEL\$1INFO。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ML_MODEL_INFO.html)
## 範例查詢
下列查詢會顯示機器學習模型的目前狀態。
```
SELECT schema_name, model_name, model_state
FROM svv_ml_model_info;
schema_name | model_name | model_state
-------------+------------------------------+--------------------------------------
public | customer_churn_auto_model | Train Model On SageMaker In Progress
public | customer_churn_xgboost_model | Model is Ready
(2 row)
```
# SVV\$1ML\$1MODEL\$1PRIVILEGES
使用 SVV\$1ML\$1MODEL\$1PRIVILEGES 來檢視明確授予叢集中使用者、角色和群組的機器學習模型許可。
下列使用者可以看見 SVV\$1ML\$1MODEL\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ML_MODEL_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1ML\$1MODEL\$1PRIVILEGES 的結果。
```
SELECT namespace_name,model_name,model_version,privilege_type,identity_name,identity_type,admin_option FROM svv_ml_model_privileges
WHERE model_name = 'test_model';
namespace_name | model_name | model_version | privilege_type | identity_name | identity_type | admin_option
----------------+------------+---------------+----------------+----------------+---------------+--------------
public | test_model | 1 | EXECUTE | reguser | user | False
public | test_model | 1 | EXECUTE | role1 | role | False
```
# SVV\$1MV\$1DEPENDENCY
SVV\$1MV\$1DEPENDENCY 資料表顯示了 Amazon Redshift 中具體化視觀表對其他具體化視觀表的相依性。
如需具體化視觀表的相關資訊，請參閱 [Amazon Redshift 中的具體化視觀表](materialized-view-overview.md)。
所有使用者都可看見 SVV\$1MV\$1DEPENDENCY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_MV_DEPENDENCY.html)
## 範例查詢
下列查詢會傳回輸出列，指出具體化視觀表 `mv_over_foo` 使用其定義中的具體化視觀表 `mv_foo` 做為相依性。
```
CREATE SCHEMA test_ivm_setup;
CREATE TABLE test_ivm_setup.foo(a INT);
CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo;
CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo;
SELECT * FROM svv_mv_dependency;
database_name | schema_name | name | dependent_database_name | dependent_schema_name | dependent_name
---------------+----------------------+-------------+-------------------------+---------------------------+----------
dev | test_ivm_setup | mv_over_foo | dev | test_ivm_setup | mv_foo
```
# SVV\$1MV\$1INFO
對於每個具體化視觀表，SVV\$1MV\$1INFO 資料表都會包含一個列，顯示資料是否過時，以及狀態資訊。
如需具體化視觀表的相關資訊，請參閱 [Amazon Redshift 中的具體化視觀表](materialized-view-overview.md)。
所有使用者都可看見 SVV\$1MV\$1INFO。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_MV_INFO.html)
## 範例查詢
若要檢視所有具體化視觀表的狀態，請執行下列查詢。
```
select * from svv_mv_info;
```
此查詢傳回下列範例輸出。
```
database_name | schema_name | user_name | name | is_stale | state | autorefresh | autorewrite
--------------+-------------------------+-----------+---------+-----------+-------+-------------+----------------
dev | test_ivm_setup | catch-22 | mv | f | 1 | 1 | 0
dev | test_ivm_setup | lotr | old_mv | t | 1 | 0 | 1
```
# SVV\$1QUERY\$1INFLIGHT
使用 SVV\$1QUERY\$1INFLIGHT 檢視來判斷正在資料庫中執行的查詢為何。此檢視會聯合 [STV\$1INFLIGHT](r_STV_INFLIGHT.md) 至 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)。SVV\$1QUERY\$1INFLIGHT 不會顯示僅限於領導節點的查詢。如需詳細資訊，請參閱[僅限領導節點函數](c_SQL_functions_leader_node_only.md)。
所有使用者都可看見 SVV\$1QUERY\$1INFLIGHT。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_QUERY_INFLIGHT.html)
## 範例查詢
以下範例輸出顯示目前執行的兩個查詢，SVV\$1QUERY\$1INFLIGHT 查詢本身和查詢 428，此在資料表中分為三個列。(在此範例輸出中開始時間和陳述式欄位遭到截斷。)
```
select slice, query, pid, starttime, suspended, trim(text) as statement, sequence
from svv_query_inflight
order by query, sequence;
slice|query| pid | starttime |suspended| statement | sequence
-----+-----+------+----------------------+---------+-----------+---------
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | select ...| 0
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | enueid ...| 1
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | atname,...| 2
1012 | 429 | 1608 | 2012-04-10 13:53:... | 0 | select ...| 0
(4 rows)
```
# SVV\$1QUERY\$1STATE
使用 SVV\$1QUERY\$1STATE 來檢視目前執行中查詢之執行期的相關資訊。
SVV\$1QUERY\$1STATE 檢視包含 STV\$1EXEC\$1STATE 資料表的資料子集。
所有使用者都可看見 SVV\$1QUERY\$1STATE。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
此資料表中的部份或所有資料也會在 SYS 監控檢視 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) 中找到。SYS 監視檢視中的資料會格式化為更易於使用和理解。我們建議您使用 SYS 監控檢視進行查詢。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_QUERY_STATE.html)
## 範例查詢
**依步驟判斷查詢處理時間**
下列查詢顯示查詢 ID 為 279 之查詢的每個步驟執行多久，以及 Amazon Redshift 處理的列多寡：
```
select query, seg, step, maxtime, avgtime, rows, label
from svv_query_state
where query = 279
order by query, seg, step;
```
此查詢會擷取查詢 279 的相關處理資訊，如下範例輸出所示：
```
query | seg | step | maxtime | avgtime | rows | label
------+---------+------+---------+---------+---------+-------------------
279 | 3 | 0 | 1658054 | 1645711 | 1405360 | scan
279 | 3 | 1 | 1658072 | 1645809 | 0 | project
279 | 3 | 2 | 1658074 | 1645812 | 1405434 | insert
279 | 3 | 3 | 1658080 | 1645816 | 1405437 | distribute
279 | 4 | 0 | 1677443 | 1666189 | 1268431 | scan
279 | 4 | 1 | 1677446 | 1666192 | 1268434 | insert
279 | 4 | 2 | 1677451 | 1666195 | 0 | aggr
(7 rows)
```
**判斷磁碟上是否有任何正在執行的作用中查詢**
以下查詢顯示作用中的查詢目前是否正在磁碟上執行：
```
select query, label, is_diskbased from svv_query_state
where is_diskbased = 't';
```
此範例輸出顯示作用中的查詢目前是否正在磁碟上執行：
```
query | label | is_diskbased
-------+--------------+--------------
1025 | hash tbl=142 | t
(1 row)
```
# SVV\$1REDSHIFT\$1COLUMNS
使用 SVV\$1REDSHIFT\$1COLUMNS 來檢視使用者有權存取的所有欄清單。這組欄包括叢集上的欄，以及遠端叢集所提供資料共用中的欄。
所有使用者都可看見 SVV\$1REDSHIFT\$1COLUMNS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_COLUMNS.html)
## 範例查詢
下列範例會傳回 SVV\$1REDSHIFT\$1COLUMNS 的輸出。
```
SELECT *
FROM svv_redshift_columns
WHERE database_name = 'tickit_db'
AND TABLE_NAME = 'tickit_sales_redshift'
ORDER BY COLUMN_NAME,
TABLE_NAME,
database_name
LIMIT 5;
database_name | schema_name | table_name | column_name | ordinal_position | data_type | column_default | is_nullable | encoding | distkey | sortkey | column_acl | remarks
--------------+-------------+-----------------------+-------------+------------------+-----------+----------------+-------------+----------+---------+---------+-------------+--------
tickit_db | public | tickit_sales_redshift | buyerid | 4 | integer | | NO | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | commission | 9 | numeric | (8,2) | YES | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | dateid | 6 | smallint | | NO | none | False | 1 | |
tickit_db | public | tickit_sales_redshift | eventid | 5 | integer | | NO | az64 | False | 0 | |
tickit_db | public | tickit_sales_redshift | listid | 2 | integer | | NO | az64 | True | 0 | |
```
# SVV\$1REDSHIFT\$1DATABASES
使用 SVV\$1 REDSHIFT\$1DATABASES 來檢視使用者有權存取的所有資料庫清單。這包括叢集上的資料庫，以及從遠端叢集所提供資料共用建立的資料庫。
根據預設，所有使用者都可看見 SVV\$1REDSHIFT\$1DATABASES。若要控制對資料庫中繼資料的存取，請為您的佈建叢集或無伺服器工作群組啟用中繼資料安全。中繼資料安全可讓您依使用者和角色區分物件中繼資料的檢視許可。如需詳細資訊，請參閱[中繼資料安全性](t_metadata_security.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_DATABASES.html)
## 範例查詢
下列範例會傳回 SVV\$1REDSHIFT\$1DATABASES 的輸出。
```
select database_name, database_owner, database_type, database_options, database_isolation_level
from svv_redshift_databases;
database_name | database_owner | database_type | database_options | database_isolation_level
--------------+----------------+---------------+------------------+------------------
dev | 1 | local | NULL | Serializable
```
# SVV\$1REDSHIFT\$1FUNCTIONS
使用 SVV\$1REDSHIFT\$1FUNCTIONS 來檢視使用者有權存取的所有函數的清單。這組函數包括叢集上的函數，以及遠端叢集所提供資料共用中的函數。
所有使用者都可看見 SVV\$1REDSHIFT\$1FUNCTIONS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_FUNCTIONS.html)
## 範例查詢
下列範例會傳回 SVV\$1REDSHIFT\$1FUNCTIONS 的輸出。
```
SELECT *
FROM svv_redshift_functions
WHERE database_name = 'tickit_db'
AND SCHEMA_NAME = 'public'
ORDER BY function_name
LIMIT 5;
database_name | schema_name | function_name | function_type | argument_type | result_type
--------------+-------------+-----------------------+------------------+------------------+-------------
tickit_db | public | shared_function | REGULAR FUNCTION | integer, integer | integer
```
# SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA
顯示資料庫中每個結構描述的配額和目前磁碟使用量。
所有使用者都可看見 SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
查詢已佈建叢集或 Redshift 無伺服器工作群組時，可使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMA_QUOTA.html)
## 範例查詢
下列範例會顯示名為 `sales_schema` 之結構描述的配額和目前磁碟使用量。
```
SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage FROM svv_redshift_schema_quota
WHERE SCHEMA_NAME = 'sales_schema';
schema_name | quota | disk_usage
--------------+-------+------------
sales_schema | 2048 | 30
```
# SVV\$1REDSHIFT\$1SCHEMAS
使用 SVV\$1REDSHIFT\$1SCHEMAS 來檢視使用者有權存取之所有結構描述的清單。這組結構描述包括叢集上的結構描述，以及遠端叢集所提供之資料庫的結構描述。
所有使用者都可看見 SVV\$1REDSHIFT\$1SCHEMAS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMAS.html)
## 範例查詢
下列範例會傳回 SVV\$1REDSHIFT\$1SCHEMAS 的輸出。
```
SELECT *
FROM svv_redshift_schemas
WHERE database_name = 'tickit_db'
ORDER BY database_name,
SCHEMA_NAME;
database_name | schema_name | schema_owner | schema_type | schema_acl | schema_option
--------------+--------------------+--------------+-------------+------------+---------------
tickit_db | public | 1 | shared | |
```
# SVV\$1REDSHIFT\$1TABLES
使用 SVV\$1REDSHIFT\$1TABLES 來檢視使用者有權存取的所有資料表清單。這組資料表包括叢集上的資料表，以及遠端叢集所提供資料共用中的資料表。
所有使用者都可看見 SVV\$1REDSHIFT\$1TABLES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_REDSHIFT_TABLES.html)
## 範例查詢
下列範例會傳回 SVV\$1REDSHIFT\$1TABLES 的輸出。
```
SELECT *
FROM svv_redshift_tables
WHERE database_name = 'tickit_db' AND TABLE_NAME LIKE 'tickit_%'
ORDER BY database_name,
TABLE_NAME;
database_name | schema_name | table_name | table_type | table_acl | remarks | table_owner
--------------+-------------+--------------------------+------------+-----------+---------+-----------
tickit_db | public | tickit_category_redshift | TABLE | | +
tickit_db | public | tickit_date_redshift | TABLE | | +
tickit_db | public | tickit_event_redshift | TABLE | | +
tickit_db | public | tickit_listing_redshift | TABLE | | +
tickit_db | public | tickit_sales_redshift | TABLE | | +
tickit_db | public | tickit_users_redshift | TABLE | | +
tickit_db | public | tickit_venue_redshift | TABLE | |
```
如果 table\$1acl 值為 null，表示沒有明確授予對應資料表的存取權限。
# SVV\$1RELATION\$1PRIVILEGES
使用 SVV\$1RELATION\$1PRIVILEGES 來檢視明確授予目前資料庫中使用者、角色和群組的關係 (資料表和檢視) 許可。
下列使用者可以看見 SVV\$1RELATION\$1PRIVILEGES：
+ 超級使用者
+ 具有 SYSLOG ACCESS UNRESTRICTED 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。如需資料可見性的詳細資訊，請參閱 [系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_RELATION_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1RELATION\$1PRIVILEGES 的結果。
```
SELECT namespace_name,relation_name,privilege_type,identity_name,identity_type,admin_option FROM svv_relation_privileges
WHERE relation_name = 'orders' AND privilege_type = 'SELECT';
namespace_name | relation_name | privilege_type | identity_name | identity_type | admin_option
----------------+---------------+----------------+----------------+---------------+--------------
public | orders | SELECT | reguser | user | False
public | orders | SELECT | role1 | role | False
```
# SVV\$1RLS\$1APPLIED\$1POLICY
使用 SVV\$1RLS\$1APPLIED\$1POLICY 可追蹤 RLS 政策在參考受 RLS 保護關係之查詢上的應用。
下列使用者可以看見 SVV\$1RLS\$1APPLIED\$1POLICY：
+ 超級使用者
+ 具有 `sys:operator` 角色的使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
請注意，sys:secadmin 未授予此系統許可。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_RLS_APPLIED_POLICY.html)
## 範例查詢
下列範例顯示 SVV\$1RLS\$1APPLIED\$1POLICY 的結果。若要查詢 SVV\$1RLS\$1APPLIED\$1POLICY，您必須具有 ACCESS SYSTEM TABLE 許可。
```
-- Check what RLS policies were applied to the run query.
SELECT username, command, datname, relschema, relname, polname, poldefault
FROM svv_rls_applied_policy
WHERE datname = CURRENT_DATABASE() AND query = PG_LAST_QUERY_ID();
username | command | datname | relschema | relname | polname | poldefault
----------+---------+-----------+-----------+--------------------------+-----------------+------------
molly | s | tickit_db | public | tickit_category_redshift | policy_concerts |
```
# SVV\$1RLS\$1ATTACHED\$1POLICY
使用 SVV\$1RLS\$1ATTACHED\$1POLICY 來檢視目前連線的資料庫上連接了一或多個列層級安全政策的所有關係和使用者清單。
只有具備 sys:secadmin 角色的使用者才能查詢此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_RLS_ATTACHED_POLICY.html)
## 範例查詢
下列範例顯示 SVV\$1RLS\$1ATTACHED\$1POLICY 的結果。
```
--Inspect the policy in SVV_RLS_ATTACHED_POLICY
SELECT * FROM svv_rls_attached_policy;
relschema | relname | relkind | polname | grantor | grantee | granteekind | is_pol_on | is_rls_on | rls_conjuntion_type
-----------+--------------------------+---------+-----------------+---------+----------+-------------+-----------+-----------+---------------------
public | tickit_category_redshift | table | policy_concerts | bob | analyst | role | True | True | and
public | tickit_category_redshift | table | policy_concerts | bob | dbadmin | role | True | True | and
```
# SVV\$1RLS\$1POLICY
使用 SVV\$1RLS\$1POLICY 來檢視在 Amazon Redshift 叢集上建立的所有列層級安全政策清單。
所有使用者都可看見 SVV\$1RLS\$1POLICY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_RLS_POLICY.html)
## 範例查詢
下列範例顯示 SVV\$1RLS\$1POLICY 的結果。
```
-- Create some policies.
CREATE RLS POLICY pol1 WITH (a int) AS t USING ( t.a IS NOT NULL );
CREATE RLS POLICY pol2 WITH (c varchar(10)) AS t USING ( c LIKE '%public%');
-- Inspect the policy in SVV_RLS_POLICY
SELECT * FROM svv_rls_policy;
poldb | polname | polalias | polatts | polqual | polenabled | polmodifiedby | polmodifiedtime
-------+---------+----------+--------------------------------------------------+---------------------------------------+------------+---------------+---------------------
my_db | pol1 | t | [{"colname":"a","type":"integer"}] | "t"."a" IS NOT NULL | t | policy_admin | 2022-02-11 14:40:49
my_db | pol2 | t | [{"colname":"c","type":"character varying(10)"}] | "t"."c" LIKE CAST('%public%' AS TEXT) | t | policy_admin | 2022-02-11 14:41:28
```
# SVV\$1RLS\$1RELATION
使用 SVV\$1RLS\$1RELATION 來檢視受到 RLS 保護的所有關係的清單。
所有使用者都可看見 SVV\$1RLS\$1RELATION。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_RLS_RELATION.html)
## 範例查詢
下列範例顯示 SVV\$1RLS\$1RELATION 的結果。
```
ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON FOR DATASHARES;
--Inspect RLS state on the relations using SVV_RLS_RELATION.
SELECT datname, relschema, relname, relkind, is_rls_on, is_rls_datashare_on FROM svv_rls_relation ORDER BY relname;
datname | relschema | relname | relkind | is_rls_on | is_rls_datashare_on | rls_conjunction_type | rls_datashare_conjunction_type
-----------+-----------+--------------------------+---------+-----------+---------------------+----------------------+--------------------------------
tickit_db | public | tickit_category_redshift | table | t | t | and | and
(1 row)
```
# SVV\$1ROLE\$1GRANTS
使用 SVV\$1ROLE\$1GRANTS 來檢視叢集中明確授予角色的角色清單。
下列使用者可以看見 SVV\$1ROLE\$1GRANTS：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ROLE_GRANTS.html)
## 範例查詢
下列範例會傳回 SVV\$1ROLE\$1GRANTS 的輸出。
```
GRANT ROLE role1 TO ROLE role2;
GRANT ROLE role2 TO ROLE role3;
SELECT role_name, granted_role_name FROM svv_role_grants;
role_name | granted_role_name
-----------+--------------------
role2 | role1
role3 | role2
(2 rows)
```
# SVV\$1ROLES
使用 SVV\$1ROLES 來檢視角色資訊。
所有使用者都可看見此資料表。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_ROLES.html)
## 範例查詢
下列範例會傳回 SVV\$1ROLES 的輸出。
```
SELECT role_name,role_owner FROM svv_roles WHERE role_name IN ('role1', 'role2');
role_name | role_owner
-----------+------------
role1 | superuser
role2 | superuser
```
# SVV\$1SCHEMA\$1PRIVILEGES
使用 SVV\$1SCHEMA\$1PRIVILEGES 來檢視明確授予目前資料庫中使用者、角色和群組的結構描述許可。
下列使用者可以看見 SVV\$1SCHEMA\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_SCHEMA_PRIVILEGES.html)
## 範例查詢
下列範例顯示 SVV\$1SCHEMA\$1PRIVILEGES 的結果。
```
SELECT namespace_name,privilege_type,identity_name,identity_type,admin_option FROM svv_schema_privileges
WHERE namespace_name = 'test_schema1';
namespace_name | privilege_type | identity_name | identity_type | admin_option
----------------+----------------+----------------+---------------+--------------
test_schema1 | USAGE | reguser | user | False
test_schema1 | USAGE | role1 | role | False
```
# SVV\$1SCHEMA\$1QUOTA\$1STATE
顯示每個結構描述的配額和目前磁碟使用量。
一般使用者可以看到他們對其擁有 USAGE 許可之結構描述的資訊。超級使用者可以看到目前資料庫中所有結構描述的資訊。
所有使用者都可看見 SVV\$1SCHEMA\$1QUOTA\$1STATE。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_SCHEMA_QUOTA_STATE.html)
## 範例查詢
下列範例會顯示結構描述的配額和目前磁碟使用量。
```
SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage, disk_usage_pct FROM svv_schema_quota_state
WHERE SCHEMA_NAME = 'sales_schema';
schema_name | quota | disk_usage | disk_usage_pct
--------------+-------+------------+----------------
sales_schema | 2048 | 30 | 1.46
(1 row)
```
# SVV\$1SYSTEM\$1PRIVILEGES
下列使用者可以看見 SVV\$1SYSTEM\$1PRIVILEGES：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到他們有權存取或擁有的身分。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_SYSTEM_PRIVILEGES.html)
## 範例查詢
下列範例顯示指定參數的結果。
```
SELECT system_privilege,identity_name,identity_type FROM svv_system_privileges
WHERE system_privilege = 'ALTER TABLE' AND identity_name = 'sys:superuser';
system_privilege | identity_name | identity_type
------------------+---------------+---------------
ALTER TABLE | sys:superuser | role
```
# SVV\$1TABLE\$1INFO
顯示目前連線資料庫中資料表和具體化視觀表的摘要資訊。檢視會篩選掉系統資料表，並且僅顯示至少包含 1 列資料的使用者定義資料表和具體化視觀表。
您可以使用 SVV\$1TABLE\$1INFO 檢視來診斷和解決可能影響查詢效能的資料表設計問題。這包括壓縮編碼、分散索引鍵、排序樣式、資料分散扭曲、資料表大小和統計資料的問題。SVV\$1TABLE\$1INFO 檢視不會傳回空資料表的任何資訊。
SVV\$1TABLE\$1INFO 檢視會摘要來自下列系統資料表和目錄資料表的資訊：
+ [STV\$1NODE\$1STORAGE\$1CAPACITY](r_STV_NODE_STORAGE_CAPACITY.md)
+ [STV\$1SLICES](r_STV_SLICES.md)
+ [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md)
+ [PG\$1ATTRIBUTE](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html)
+ [PG\$1CLASS](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html)
+ [PG\$1DATABASE](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html)
+ [PG\$1NAMESPACE](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html)
+ [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md)
只有超級使用者才能看到 SVV\$1TABLE\$1INFO。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。若要允許使用者查詢檢視，請將 SVV\$1TABLE\$1INFO 上的 SELECT 許可授予給使用者。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_TABLE_INFO.html)
## 範例查詢
下列範例顯示資料庫中所有使用者定義資料表的編碼、分佈樣式、排序和資料扭曲。此處的 "table" 必須使用雙引號括起來，因為這是保留字。
```
select "table", encoded, diststyle, sortkey1, skew_sortkey1, skew_rows
from svv_table_info
order by 1;
table | encoded | diststyle | sortkey1 | skew_sortkey1 | skew_rows
---------------+---------+-----------------+--------------+---------------+----------
category | N | EVEN | | |
date | N | ALL | dateid | 1.00 |
event | Y | KEY(eventid) | dateid | 1.00 | 1.02
listing | Y | KEY(listid) | dateid | 1.00 | 1.01
sales | Y | KEY(listid) | dateid | 1.00 | 1.02
users | Y | KEY(userid) | userid | 1.00 | 1.01
venue | N | ALL | venueid | 1.00 |
(7 rows)
```
# SVV\$1TABLES
使用 SVV\$1TABLES 來檢視本機和外部目錄中的資料表。
根據預設，所有使用者都可看見 SVV\$1TABLES。若要控制對資料庫中繼資料的存取，請為您的佈建叢集或無伺服器工作群組啟用中繼資料安全。中繼資料安全可讓您依使用者和角色區分物件中繼資料的檢視許可。如需詳細資訊，請參閱[中繼資料安全性](t_metadata_security.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_TABLES.html)
# SVV\$1TRANSACTIONS
記錄資料庫中目前保持鎖定之資料表的交易相關資訊。使用 SVV\$1TRANSACTIONS 檢視以識別開啟交易與鎖定爭用的問題。如需鎖定的相關資訊，請參閱 [管理並行寫入操作](c_Concurrent_writes.md) 和 [LOCK](r_LOCK.md)。
所有使用者都可看見 SVV\$1TRANSACTIONS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_TRANSACTIONS.html)
## 範例查詢
下列命令顯示所有作用中的交易且每個交易請求的鎖定數。
```
select * from svv_transactions;
txn_ lockable_
owner | txn_db | xid | pid | txn_start | lock_mode | object_type | relation | granted
-------+--------+--------+-------+----------------------------+---------------------+----------------+----------+---------
root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | AccessShareLock | relation | 100068 | t
root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | ExclusiveLock | transactionid | | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 50860 | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 52310 | t
root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | ExclusiveLock | transactionid | | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100068 | f
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | RowExclusiveLock | relation | 16688 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessShareLock | relation | 100064 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100166 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100171 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100190 | t
root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | ExclusiveLock | transactionid | | t
(12 rows)
(12 rows)
```
# SVV\$1USER\$1GRANTS
使用 SVV\$1USER\$1GRANTS 來檢視叢集中明確授予角色的使用者清單。
下列使用者可以看見 SVV\$1USER\$1GRANTS：
+ 超級使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
其他使用者只能看到明確授予他們的角色。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_USER_GRANTS.html)
## 範例查詢
下列查詢會將角色授予使用者，並顯示明確授予角色的使用者清單。
```
GRANT ROLE role1 TO reguser;
GRANT ROLE role2 TO reguser;
GRANT ROLE role1 TO superuser;
GRANT ROLE role2 TO superuser;
SELECT user_name,role_name,admin_option FROM svv_user_grants;
user_name | role_name | admin_option
-----------+-----------+--------------
superuser | role1 | False
reguser | role1 | False
superuser | role2 | False
reguser | role2 | False
```
# SVV\$1USER\$1INFO
您可以使用 SVV\$1USER\$1INFO 檢視來擷取關於 Amazon Redshift 資料庫使用者的資料。
所有使用者都可看見 SVV\$1USER\$1INFO。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_USER_INFO.html)
## 範例查詢
下列命令會從 SVV\$1USER\$1INFO 擷取使用者資訊。
```
SELECT * FROM SVV_USER_INFO;
```
# SVV\$1VACUUM\$1PROGRESS
此檢視會傳回目前進行中的清空操作所需完成時間的預估值。
只有超級使用者才能看到 SVV\$1VACUUM\$1PROGRESS。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
此資料表中的部份或所有資料也會在 SYS 監控檢視 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 監視檢視中的資料會格式化為更易於使用和理解。我們建議您使用 SYS 監控檢視進行查詢。
如需 SVV\$1VACUUM\$1SUMMARY 的相關資訊，請參閱 [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md)。
如需 SVL\$1VACUUM\$1PERCENTAGE 的相關資訊，請參閱 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_VACUUM_PROGRESS.html)
## 範例查詢
幾分鐘前執行的下列查詢會顯示正在清空之名為 SALESNEW 的大型資料表。
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
--------------+-------------------------------+-------------------------
salesnew | Vacuum: initialize salesnew |
(1 row)
...
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+------------------------+-------------------------
salesnew | Vacuum salesnew sort | 33m 21s
(1 row)
```
下列查詢顯示目前沒有在進行任何清空操作。前次執行清空的資料表是 SALES 資料表。
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+----------+-------------------------
sales | Complete |
(1 row)
```
# SVV\$1VACUUM\$1SUMMARY
SVV\$1VACUUM\$1SUMMARY 檢視會結合 STL\$1VACUUM、STL\$1QUERY、STV\$1TBL\$1PERM 資料表，摘要系統所記錄之清空操作的相關資訊。檢視會根據清空交易和資料表傳回一個資料列。檢視會記錄操作的經過時間、建立之排序分割區數、所需合併增量數和操作執行前後的資料列和區塊計數的差異。
只有超級使用者才能看到 SVV\$1VACUUM\$1SUMMARY。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
此資料表中的部份或所有資料也會在 SYS 監控檢視 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md) 中找到。SYS 監視檢視中的資料會格式化為更易於使用和理解。我們建議您使用 SYS 監控檢視進行查詢。
如需 SVV\$1VACUUM\$1PROGRESS 的相關資訊，請參閱 [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md)。
如需 SVL\$1VACUUM\$1PERCENTAGE 的相關資訊，請參閱 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)。
**注意**
只有在查詢已佈建的叢集時，才能使用此檢視。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SVV_VACUUM_SUMMARY.html)
## 範例查詢
下列查詢會傳回在三個不同資料表上清空操作的統計資訊。SALES 資料表執行了兩次清空。
```
select table_name, xid, sort_partitions as parts, merge_increments as merges,
elapsed_time, row_delta, sortedrow_delta as sorted_delta, block_delta
from svv_vacuum_summary
order by xid;
table_ | xid |parts|merges| elapsed_ | row_ | sorted_ | block_
name | | | | time | delta | delta | delta
--------+------+-----+------+----------+---------+---------+--------
users | 2985 | 1 | 1 | 61919653 | 0 | 49990 | 20
category| 3982 | 1 | 1 | 24136484 | 0 | 11 | 0
sales | 3992 | 2 | 1 | 71736163 | 0 | 1207192 | 32
sales | 4000 | 1 | 1 | 15363010 | -851648 | -851648 | -140
(4 rows)
```
# SYS 監控檢視
*監控檢視*是 Amazon Redshift 中的系統檢視，用於監控佈建叢集和無伺服器工作群組的查詢和工作負載資源使用情況。這些檢視位於 `pg_catalog` 結構描述中。若要顯示這些檢視提供的資訊，請執行 SQL SELECT 陳述式。
除非另有說明，否則這些檢視可用於 Amazon Redshift 叢集和 Amazon Redshift Serverless 工作群組。
*SYS\$1SERVERLESS\$1USAGE* 只收集 Amazon Redshift Serverless 的使用資料。
**Topics**
+ [
# SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
](r_SYS_ANALYZE_COMPRESSION_HISTORY.md)
+ [
# SYS\$1ANALYZE\$1HISTORY
](SYS_ANALYZE_HISTORY.md)
+ [
# SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG
](SYS_APPLIED_MASKING_POLICY_LOG.md)
+ [
# SYS\$1AUTOMATIC\$1OPTIMIZATION
](SYS_AUTOMATIC_OPTIMIZATION.md)
+ [
# SYS\$1AUTO\$1TABLE\$1OPTIMIZATION
](r_SYS_AUTO_TABLE_OPTIMIZATION.md)
+ [
# SYS\$1CHILD\$1QUERY\$1TEXT
](SYS_CHILD_QUERY_TEXT.md)
+ [
# SYS\$1CONNECTION\$1LOG
](SYS_CONNECTION_LOG.md)
+ [
# SYS\$1COPY\$1JOB
](SYS_COPY_JOB.md)
+ [
# SYS\$1COPY\$1JOB\$1DETAIL
](SYS_COPY_JOB_DETAIL.md)
+ [
# SYS\$1COPY\$1JOB\$1INFO
](SYS_COPY_JOB_INFO.md)
+ [
# SYS\$1COPY\$1REPLACEMENTS
](SYS_COPY_REPLACEMENTS.md)
+ [
# SYS\$1DATASHARE\$1CHANGE\$1LOG
](SYS_DATASHARE_CHANGE_LOG.md)
+ [
# SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
](r_SYS_DATASHARE_CROSS_REGION_USAGE.md)
+ [
# SYS\$1DATASHARE\$1USAGE\$1CONSUMER
](SYS_DATASHARE_USAGE_CONSUMER.md)
+ [
# SYS\$1DATASHARE\$1USAGE\$1PRODUCER
](SYS_DATASHARE_USAGE_PRODUCER.md)
+ [
# SYS\$1EXTERNAL\$1QUERY\$1DETAIL
](SYS_EXTERNAL_QUERY_DETAIL.md)
+ [
# SYS\$1EXTERNAL\$1QUERY\$1ERROR
](SYS_EXTERNAL_QUERY_ERROR.md)
+ [
# SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION
](SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.md)
+ [
# SYS\$1INTEGRATION\$1ACTIVITY
](r_SYS_INTEGRATION_ACTIVITY.md)
+ [
# SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY
](r_SYS_INTEGRATION_TABLE_ACTIVITY.md)
+ [
# SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE
](r_SYS_INTEGRATION_TABLE_STATE_CHANGE.md)
+ [
# SYS\$1LOAD\$1DETAIL
](SYS_LOAD_DETAIL.md)
+ [
# SYS\$1LUDF\$1DETAIL
](SYS_LUDF_DETAIL.md)
+ [
# SYS\$1LOAD\$1ERROR\$1DETAIL
](SYS_LOAD_ERROR_DETAIL.md)
+ [
# SYS\$1LOAD\$1HISTORY
](SYS_LOAD_HISTORY.md)
+ [
# SYS\$1MV\$1REFRESH\$1HISTORY
](SYS_MV_REFRESH_HISTORY.md)
+ [
# SYS\$1MV\$1STATE
](SYS_MV_STATE.md)
+ [
# SYS\$1PROCEDURE\$1CALL
](SYS_PROCEDURE_CALL.md)
+ [
# SYS\$1PROCEDURE\$1MESSAGES
](SYS_PROCEDURE_MESSAGES.md)
+ [
# SYS\$1QUERY\$1DETAIL
](SYS_QUERY_DETAIL.md)
+ [
# SYS\$1QUERY\$1EXPLAIN
](SYS_QUERY_EXPLAIN.md)
+ [
# SYS\$1QUERY\$1HISTORY
](SYS_QUERY_HISTORY.md)
+ [
# SYS\$1QUERY\$1TEXT
](SYS_QUERY_TEXT.md)
+ [
# SYS\$1REDSHIFT\$1TEMPLATE
](SYS_REDSHIFT_TEMPLATE.md)
+ [
# SYS\$1RESTORE\$1LOG
](SYS_RESTORE_LOG.md)
+ [
# SYS\$1RESTORE\$1STATE
](SYS_RESTORE_STATE.md)
+ [
# SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md)
+ [
# SYS\$1SERVERLESS\$1USAGE
](SYS_SERVERLESS_USAGE.md)
+ [
# SYS\$1SESSION\$1HISTORY
](SYS_SESSION_HISTORY.md)
+ [
# SYS\$1SPATIAL\$1SIMPLIFY
](SYS_SPATIAL_SIMPLIFY.md)
+ [
# SYS\$1STREAM\$1SCAN\$1ERRORS
](r_SYS_STREAM_SCAN_ERRORS.md)
+ [
# SYS\$1STREAM\$1SCAN\$1STATES
](r_SYS_STREAM_SCAN_STATES.md)
+ [
# SYS\$1TRANSACTION\$1HISTORY
](SYS_TRANSACTION_HISTORY.md)
+ [
# SYS\$1UDF\$1LOG
](SYS_UDF_LOG.md)
+ [
# SYS\$1UNLOAD\$1DETAIL
](SYS_UNLOAD_DETAIL.md)
+ [
# SYS\$1UNLOAD\$1HISTORY
](SYS_UNLOAD_HISTORY.md)
+ [
# SYS\$1USERLOG
](SYS_USERLOG.md)
+ [
# SYS\$1VACUUM\$1HISTORY
](SYS_VACUUM_HISTORY.md)
# SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
記錄在 COPY 或 ANALYZE COMPRESSION 命令期間的壓縮分析操作詳細資訊。
所有使用者都可看見 SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_ANALYZE_COMPRESSION_HISTORY.html)
## 範例查詢
下列範例由在相同工作階段中執行的最後一項 COPY 命令檢查 `lineitem` 資料表上的壓縮分析詳細資料。
```
select transaction_id, table_id, btrim(table_name) as table_name, column_position, old_encoding, new_encoding, mode
from sys_analyze_compression_history
where transaction_id = (select transaction_id from sys_query_history where query_id = pg_last_copy_id()) order by column_position;
transaction_id | table_id | table_name | column_position | old_encoding | new_encoding | mode
-----------------+-------------+------------+-----------------+-----------------+-----------------+-------------
8196 | 248126 | lineitem | 0 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 1 | mostly32 | lzo | ON
8196 | 248126 | lineitem | 2 | lzo | delta32k | ON
8196 | 248126 | lineitem | 3 | delta | delta | ON
8196 | 248126 | lineitem | 4 | bytedict | bytedict | ON
8196 | 248126 | lineitem | 5 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 6 | delta | delta | ON
8196 | 248126 | lineitem | 7 | delta | delta | ON
8196 | 248126 | lineitem | 8 | lzo | zstd | ON
8196 | 248126 | lineitem | 9 | runlength | zstd | ON
8196 | 248126 | lineitem | 10 | delta | lzo | ON
8196 | 248126 | lineitem | 11 | delta | delta | ON
8196 | 248126 | lineitem | 12 | delta | delta | ON
8196 | 248126 | lineitem | 13 | bytedict | zstd | ON
8196 | 248126 | lineitem | 14 | bytedict | zstd | ON
8196 | 248126 | lineitem | 15 | text255 | zstd | ON
(16 rows)
```
# SYS\$1ANALYZE\$1HISTORY
記錄 [ANALYZE](https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE.html) 操作的詳細資訊。
只有超級使用者才能看到 SYS\$1ANALYZE\$1HISTORY。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_ANALYZE_HISTORY.html)
## 範例查詢
```
user_id | transaction_id | database_name | schema_name | table_name | table_id | is_automatic | Status | start_time | end_time | rows | modified_rows | analyze_threshold_percent | last_analyze_time
---------+----------------+---------------+-------------+---------------------+----------+--------------+--------+----------------------------+----------+-----------------+------+---------------+---------------------------+---------------------
101 | 8006 | dev | public | test_table_562bf8dc | 110427 | f | Full | 2023-09-21 18:33:08.504646 | 2023-09-21 18:33:24.296498 | 5 | 5 | 0 | 2000-01-01 00:00:00
```
# SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG
使用 SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG 追蹤動態資料遮罩政策套用在參考受 DDM 保護之關係的查詢上的情形。
下列使用者可以看見 SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG：
+ 超級使用者
+ 具有 `sys:operator` 角色的使用者
+ 具有 ACCESS SYSTEM TABLE 許可的使用者
一般使用者將看到 0 列。
請注意，具有 `sys:secadmin` 角色的使用者看不見 SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG。
如需動態資料遮罩的詳細資訊，請前往 [動態資料遮罩](t_ddm.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_APPLIED_MASKING_POLICY_LOG.html)
## 範例查詢
下列範例顯示 `mask_credit_card_full` 遮罩政策已連接至 `credit_db.public.credit_cards` 資料表。
```
select policy_name, database_name, relation_name, schema_name, relation_kind
from sys_applied_masking_policy_log;
policy_name | database_name | relation_name | schema_name | relation_kind
----------------------+---------------+---------------+-------------+---------------
mask_credit_card_full | credit_db | credit_cards | public | table
(1 row)
```
# SYS\$1AUTOMATIC\$1OPTIMIZATION
使用 SYS\$1AUTOMATIC\$1OPTIMIZATION 來檢視 Amazon Redshift 執行以進行自動最佳化之任務的詳細資訊，也稱為自主。如需自動最佳化的詳細資訊，請參閱 [自動資料庫最佳化](c_autonomics.md)。
只有超級使用者可以看到 SYS\$1AUTOMATIC\$1OPTIMIZATION。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_AUTOMATIC_OPTIMIZATION.html)
## 使用須知
無伺服器叢集的 compute\$1type 資料欄將為空，因為我們無法區分主要或主要規模的運算資源。無伺服器叢集運算資源是以 Redshift 處理單元 (RPUs用量來測量。如需詳細資訊，請參閱 [Amazon Redshift Serverless 的運算容量](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-capacity.html)。
## 範例
下列查詢顯示資料表 155259 上執行的自動最佳化。
```
SELECT pid, trim(task_type) as task_type,
trim(database) as database,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE object_ids like '%155259%'
AND status = 'Task completed successfully';
task_type | database | status | event | event_time
------------+----------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
```
下列查詢顯示所有執行的自動「VacuumSort」最佳化。如需「VacuumSort」的詳細資訊，請參閱[自動資料表排序](t_Reclaiming_storage_space202.md#automatic-table-sort)。
```
SELECT trim(task_type) as task_type,
trim(database) as database,
trim(object_type) as object_type,
trim(object_ids) as object_ids,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE task_type like '%VacuumSort%'
AND status = 'Task completed successfully';
task_type | database | object_type | object_ids | status | event | event_time
------------+----------------+-------------+------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | table | 155301 | Task completed successfully | Completed | 2025-12-22 07:14:00.065391
VacuumSort | tpcds_100g_oob | table | 155303 | Task completed successfully | Completed | 2025-12-22 07:14:09.158251
VacuumSort | tpcds_100g_oob | table | 155291 | Task completed successfully | Completed | 2025-12-22 07:17:06.61164
VacuumSort | tpcds_100g_oob | table | 155293 | Task completed successfully | Completed | 2025-12-22 07:17:37.015069
VacuumSort | tpcds_100g_oob | table | 155281 | Task completed successfully | Completed | 2025-12-22 07:18:54.903935
VacuumSort | tpcds_100g_oob | table | 155279 | Task completed successfully | Completed | 2025-12-22 07:20:13.960002
VacuumSort | tpcds_100g_oob | table | 155271 | Task completed successfully | Completed | 2025-12-22 07:21:26.095549
VacuumSort | tpcds_100g_oob | table | 155267 | Task completed successfully | Completed | 2025-12-22 07:22:48.119249
VacuumSort | tpcds_100g_oob | table | 155269 | Task completed successfully | Completed | 2025-12-22 07:24:12.010424
VacuumSort | tpcds_100g_oob | table | 155263 | Task completed successfully | Completed | 2025-12-22 07:25:35.958388
VacuumSort | tpcds_100g_oob | table | 155265 | Task completed successfully | Completed | 2025-12-22 07:26:40.580395
VacuumSort | tpcds_100g_oob | table | 155259 | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
(12 rows)
```
# SYS\$1AUTO\$1TABLE\$1OPTIMIZATION
記錄 Amazon Redshift 對自動最佳化而定義的資料表執行的自動操作。
只有超級使用者才能看見 SYS\$1AUTO\$1TABLE\$1OPTIMIZATION。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_AUTO_TABLE_OPTIMIZATION.html)
## 範例查詢
在下列範例中，結果中的列顯示 Amazon Redshift 所採取的動作。
```
SELECT table_id, alter_table_type, status, event_time, alter_from
FROM SYS_AUTO_TABLE_OPTIMIZATION;
table_id | alter_table_type | status | event_time | alter_from
----------+---------------------+------------------------------------------------------+-----------------------------+-----------------
118082 | sortkey | Start | 2020-08-22 19:42:20.727049 |
118078 | sortkey | Start | 2020-08-22 19:43:54.728819 |
118082 | sortkey | Start | 2020-08-22 19:42:52.690264 |
118072 | sortkey | Start | 2020-08-22 19:44:14.793572 |
118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 |
118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | SORTKEY: None;
118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | SORTKEY: None;
118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | SORTKEY: None;
118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 |
118086 | sortkey | Start | 2020-08-22 19:42:00.685255 |
118082 | sortkey | Start | 2020-08-22 19:43:34.69531 |
118072 | sortkey | Start | 2020-08-22 19:44:46.703331 |
118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 |
118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 |
116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 |
110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 |
```
# SYS\$1CHILD\$1QUERY\$1TEXT
傳回子查詢的 SQL 文字。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_CHILD_QUERY_TEXT.html)
## 範例查詢
在下列範例中，結果中的列顯示 Amazon Redshift 所採取的動作。
```
SELECT * from sys_child_query_text where query_id = '34487366' order by child_query_sequence asc, sequence asc;
user_id | query_id | child_query_sequence | sequence | text
--------|----------|----------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 34899339 | 1 | 0 | /* RQEV2-aY6ZZ1ZpQK */\nwith venue as (\n select venueid,\n venuename,\n venuestate\n from venue\n), event as (\n select eventid,\n venueid,\n date
100 | 34899339 | 1 | 1 | id,\n eventname\n from event\n where eventname like '3 Doors Down'\n), users as (\n select userid\n from users\n), sales as (\n select salesid,\n pricepaid,
100 | 34899339 | 1 | 2 | \n eventid,\n buyerid\n from sales\n)\nselect e.eventname,\n v.venuename,\n count(distinct(u.userid)) as unique_customers,\n sum(s.pricepaid) as total_sal
100 | 34899339 | 1 | 3 | es\nfrom venue as v inner join event e on v.venueid = e.venueid\ninner join sales s on e.eventid = s.eventid inner join users u on s.buyerid = u.userid\ngroup by 1,2\norder by 4 desc limit 100
```
# SYS\$1CONNECTION\$1LOG
記錄身分驗證嘗試以及連線和中斷連線。
只有超級使用者才能看到 SYS\$1CONNECTION\$1LOG。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_CONNECTION_LOG.html)
## 範例查詢
若要檢視已開啟之連線的詳細資訊，請執行下列查詢。
```
select record_time, user_name, database_name, remote_host, remote_port
from sys_connection_log
where event = 'initiating session'
and session_id not in
(select session_id from sys_connection_log
where event = 'disconnecting session')
order by 1 desc;
record_time | user_name | database_name | remote_host | remote_port
--------------------+-------------+-----------------+---------------+---------------------------------
2014-11-06 20:30:06 | rdsdb | dev | [local] |
2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111
2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333
2014-11-05 20:28:35 | rdsdb | dev | [local] |
(4 rows)
```
下列範例反映失敗的身分驗證嘗試，以及成功的連線和中斷連線。
```
select event, record_time, remote_host, user_name
from sys_connection_log order by record_time;
event | record_time | remote_host | user_name
-----------------------+----------------------------+---------------+---------
authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john
authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john
initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john
disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john
(4 rows)
```
下列範例顯示 ODBC 驅動程式的版本、用戶端機器上的作業系統，以及用來連線到 Amazon Redshift 叢集的外掛程式。在此範例中，使用的外掛程式用於使用登入名稱和密碼進行標準 ODBC 驅動程式驗證。
```
select driver_version, os_version, plugin_name from sys_connection_log;
driver_version | os_version | plugin_name
----------------------------------------+-----------------------------------+--------------------
Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none
Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none
```
下列範例顯示用戶端電腦上的作業系統版本、驅動程式版本和通訊協定版本。
```
select os_version, driver_version, protocol_version from sys_connection_log;
os_version | driver_version | protocol_version
--------------------------------+------------------------------+--------------------
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
```
# SYS\$1COPY\$1JOB
使用 SYS\$1COPY\$1JOB 來檢視 COPY JOB 命令的詳細資訊。
此檢視包含已建立的 COPY JOB 命令。
所有使用者都可看見 SYS\$1COPY\$1JOB。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_COPY_JOB.html)
# SYS\$1COPY\$1JOB\$1DETAIL
使用 SYS\$1COPY\$1JOB\$1DETAIL 來檢視 COPY JOB 命令的詳細資訊。
此檢視包含已建立的 COPY JOB 命令。如果 COPY JOB 嘗試載入檔案，但載入失敗，則後續自動 COPY JOB 嘗試都會略過該檔案。
所有使用者都可看見 SYS\$1COPY\$1JOB\$1DETAIL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_COPY_JOB_DETAIL.html)
下列範例會傳回一列，代表已擷取項目。
```
SELECT * FROM SYS_COPY_JOB_DETAIL WHERE status ilike '%ingested%' limit 1;
user_id | 100
database_name | dev
job_name | many_job_4_3
job_id | 110702
file_location | saral-sqs-system4623202051-0
file_name | frenzy-9/4623202051/file_0_107
file_size | 11302
file_etag | 51b2d78ac5b5aecf4ee6f8374815ad19
modification_time | 2024-07-15 20:43:14
enqueue_time | 2024-07-15 20:44:24
status | Ingested
```
# SYS\$1COPY\$1JOB\$1INFO
使用 SYS\$1COPY\$1JOB\$1INFO 來檢視有關 COPY JOB 的記錄訊息。
此檢視包含已執行 COPY JOB 中錯誤的相關資訊。
所有使用者都可看見 SYS\$1COPY\$1JOB\$1INFO。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_COPY_JOB_INFO.html)
# SYS\$1COPY\$1REPLACEMENTS
顯示一個日誌，其記錄搭配 ACCEPTINVCHARS 選項的 [COPY](r_COPY.md) 命令何時取代無效的 UTF-8 字元。在至少需要一個取代項目的每個節點上，對於其前 100 個列的每一個都會新增一個日誌項目至 SYS\$1COPY\$1REPLACEMENTS。
您可以使用此檢視來查看有關無伺服器工作群組和已佈建叢集的資訊。
所有使用者都可看見 SYS\$1COPY\$1REPLACEMENTS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_COPY_REPLACEMENTS.html)
## 範例查詢
下列範例會傳回最新 COPY 操作的取代項目。
```
select query_idp, table_id, file_name, line_number, colname
from sys_copy_replacements
where query = pg_last_copy_id();
query_id | table_id | file_name | line_number | column_name
---------+----------+-------------------------------------------------------+-------------+--------
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 123 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 456 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 789 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 012 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 119 | city
...
```
# SYS\$1DATASHARE\$1CHANGE\$1LOG
記錄用於追蹤生產者和消費者叢集上資料共用變更的合併檢視。
所有使用者都可看見 SYS\$1DATASHARE\$1CHANGE\$1LOG。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_DATASHARE_CHANGE_LOG.html)
## 範例查詢
下列範例顯示 SYS\$1DATASHARE\$1CHANGE\$1LOG 檢視。
```
SELECT DISTINCT action
FROM sys_datashare_change_log
WHERE share_object_name LIKE 'tickit%';
action
-----------------------
"ALTER DATASHARE ADD"
```
# SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
使用 SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 檢視，可取得跨區域資料共用查詢所造成之跨區域資料傳輸使用量的摘要。SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 彙總區段層級的詳細資料。
只有超級使用者才能看到 SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_DATASHARE_CROSS_REGION_USAGE.html)
## 範例查詢
下列範例顯示 SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 檢視。
```
SELECT query_id, segment_id, transferred_data, source_region
from sys_datashare_cross_region_usage
where query_id = pg_last_query_id()
order by query_id, segment_id;
query_id | segment_id | transferred_data | source_region
-----------+------------+------------------+---------------
200048 | 2 | 4194304 | us-west-1
200048 | 2 | 4194304 | us-east-2
```
# SYS\$1DATASHARE\$1USAGE\$1CONSUMER
記錄資料共用的活動和使用情況。此檢視僅與消費者叢集相關。
所有使用者都可看見 SYS\$1DATASHARE\$1USAGE\$1CONSUMER。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_DATASHARE_USAGE_CONSUMER.html)
## 範例查詢
下列範例顯示 SYS\$1DATASHARE\$1USAGE\$1CONSUMER 檢視。
```
SELECT request_type, status, trim(error) AS error
FROM sys_datashare_usage_consumer
request_type | status | error_message
----------------+--------+---------------
"GET RELATION" | 0 |
```
# SYS\$1DATASHARE\$1USAGE\$1PRODUCER
記錄資料共用的活動和使用情況。此檢視僅與生產者叢集相關。
所有使用者都可看見 SYS\$1DATASHARE\$1USAGE\$1PRODUCER。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_DATASHARE_USAGE_PRODUCER.html)
## 範例查詢
下列範例顯示 SYS\$1DATASHARE\$1USAGE\$1PRODUCER 檢視。
```
SELECT DISTINCT
FROM sys_datashare_usage_producer
WHERE object_name LIKE 'tickit%';
request_type
------------------
"GET RELATION"
```
# SYS\$1EXTERNAL\$1QUERY\$1DETAIL
使用 SYS\$1EXTERNAL\$1QUERY\$1DETAIL 來檢視區段層級的查詢詳細資料。每一列代表特定 WLM 查詢的區段，其中包含處理的列數、處理的位元組數以及 Amazon S3 中外部資料表的分割區資訊等詳細資訊。此檢視中的每一列在 SYS\$1QUERY\$1DETAIL 檢視中也會有一個對應的項目，但此檢視包含與外部查詢處理相關的更多詳細資訊。
所有使用者都可看見 SYS\$1EXTERNAL\$1QUERY\$1DETAIL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_EXTERNAL_QUERY_DETAIL.html)
## 範例查詢
下列查詢會顯示外部查詢詳細資訊。
```
SELECT query_id,
segment_id,
start_time,
end_time,
total_partitions,
qualified_partitions,
scanned_files,
returned_rows,
returned_bytes,
trim(external_query_text) query_text,
trim(file_location) file_location
FROM sys_external_query_detail
ORDER BY query_id, start_time DESC
LIMIT 2;
```
輸出範例。
```
query_id | segment_id | start_time | end_time | total_partitions | qualified_partitions | scanned_files | returned_rows | returned_bytes | query_text | file_location
----------+------------+----------------------------+----------------------------+------------------+----------------------+---------------+---------------+----------------+------------+---------------
763251 | 0 | 2022-02-15 22:32:23.312448 | 2022-02-15 22:32:24.036023 | 3 | 3 | 3 | 38203 | 2683414 | |
763254 | 0 | 2022-02-15 22:32:40.17103 | 2022-02-15 22:32:40.839313 | 3 | 3 | 3 | 38203 | 2683414 | |
```
# SYS\$1EXTERNAL\$1QUERY\$1ERROR
您可以查詢系統檢視 SYS\$1EXTERNAL\$1QUERY\$1ERROR，以取得有關 Redshift Spectrum 掃描錯誤的資訊。SYS\$1EXTERNAL\$1QUERY\$1ERROR 會顯示記錄錯誤的範例。預設值是每個查詢 10 個項目。
所有使用者都可看見 SYS\$1EXTERNAL\$1QUERY\$1ERROR。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_EXTERNAL_QUERY_ERROR.html)
## 範例查詢
下列查詢會傳回執行資料處理操作的列清單。
```
SELECT * FROM sys_external_query_error;
```
此查詢會傳回類似以下的結果。
```
user_id query_id file_location rowid column_name original_value modified_value trigger action action_value error_code
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
```
# SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION
使用 SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION 來檢視 Amazon Redshift 使用額外運算資源執行自動最佳化任務的使用期間。如需自動最佳化的詳細資訊，請參閱 [自動資料庫最佳化](c_autonomics.md)。如需使用額外運算資源執行自動最佳化的詳細資訊，請參閱 [配置額外的運算資源以進行自動資料庫最佳化](t_extra-compute-autonomics.md)。
SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION 僅適用於佈建的叢集。
只有超級使用者可以看到 SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.html)
## 範例
以下是在 2025 年 9 月 16 日尋找自動最佳化的範例查詢。
```
SELECT *
FROM sys_extra_compute_for_automatic_optimization
WHERE start_time BETWEEN '2025-09-16 00:00:00' AND '2025-09-16 23:59:59';
start_time | end_time | query_count | compute_seconds
---------------------+---------------------+-------------+-----------------
2025-09-16 00:00:00 | 2025-09-16 00:00:59 | 1 | 59
2025-09-16 00:01:05 | 2025-09-16 00:01:58 | 2 | 53
```
# SYS\$1INTEGRATION\$1ACTIVITY
SYS\$1INTEGRATION\$1ACTIVITY 會顯示已完成整合執行的相關資訊。
只有超級使用者才能看到 SYS\$1INTEGRATION\$1ACTIVITY。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
如需零 ETL 整合的相關資訊，請參閱 Amazon Redshift 管理指南中的[使用零 ETL 整合](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html)
## 範例查詢
下列 SQL 命令會顯示整合的記錄。
```
select * from sys_integration_activity;
integration_id | target_database | source | checkpoint_name | checkpoint_type | checkpoint_bytes | last_commit_timestamp | modified_tables | integration_start_time | integration_end_time
--------------------------------------+-----------------+--------+---------------------------------------------+------------------+------------------+-------------------------+-----------------+----------------------------+----------------------------
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_241_3_510.json | cdc | 762 | 2023-05-10 23:00:14.201 | 1 | 2023-05-10 23:00:45.054265 | 2023-05-10 23:00:46.339826
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_16329_3_17839.json | cdc | 13488 | 2023-05-11 01:33:57.411 | 2 | 2023-05-11 02:19:09.440121 | 2023-05-11 02:19:16.090492
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_5103_3_5532.json | cdc | 1657 | 2023-05-10 23:13:14.205 | 2 | 2023-05-10 23:13:23.545487 | 2023-05-10 23:13:25.652144
```
# SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY
SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY 會顯示零 ETL 整合的插入、刪除和更新活動的詳細資訊。每次完成擷取都會新增一列。
超級使用者可以查看此資料表中的所有列。
如需詳細資訊，請參閱[零 ETL 整合](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_ACTIVITY.html)
## 範例查詢
下列 SQL 命令會顯示擷取的活動。
```
select * from sys_integration_table_activity;
integration_id | checkpoint_name | target_database | schema_name | table_name | table_id | record_time | transaction_id | inserted_rows | deleted_rows | updated_rows | bytes_ingested
--------------------------------------+-----------------+-----------------+-------------+-------------------+--------------+----------------------------+-----------------+----------------+--------------+--------------+---------------
4798e675-8f9f-4686-b05f-92c538e19629 | | sample_test2 | sample | SampleTestChannel | 111276 | 2023-05-12 12:40:30.656625 | 7736 | 2 | 0 | 0 | 125
```
# SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE
SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE 會顯示整合的資料表狀態變更日誌。
超級使用者可以查看此資料表中的所有列。
如需詳細資訊，請參閱[使用零 ETL 整合](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html)
## 範例查詢
下列 SQL 命令會顯示整合的記錄。
```
select * from sys_integration_table_state_change;
integration_id | database_name | schema_name | table_name | new_state | table_last_replicated_checkpoint | state_change_reason | record_time
--------------------------------------+---------------+-------------+------------+-----------+-------------------------------------+---------------------+----------------------------
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest79 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:50.087868
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest56 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:45.54005
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest50 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:20.362504
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest18 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:32.544084
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest40t3s | sbtest23 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 15:49:05.186209
```
# SYS\$1LOAD\$1DETAIL
傳回資訊以追蹤資料載入或對其進行故障診斷。
此檢視會在每一個資料檔案載入至資料庫資料表時記錄其進度。
所有使用者都可看見此檢視。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_LOAD_DETAIL.html)
## 範例查詢
下列範例傳回上次 COPY 操作的詳細資訊。
```
select query_id, trim(file_name) as file, record_time
from sys_load_detail
where query_id = pg_last_copy_id();
query_id | file | record_time
----------+----------------------------------+----------------------------
28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486
(1 row)
```
下列查詢包含 TICKIT 資料庫中全新載入之資料表的項目：
```
select query_id, trim(file_name), record_time
from sys_load_detail
where file_name like '%tickit%' order by query_id;
query_id | btrim | record_time
----------+--------------------------+----------------------------
22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186
22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604
22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472
22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305
22485 | tickit/allevents_pipe.txt| 2013-02-08 20:58:29.99489
22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939
22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491
22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055
22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049
22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502
22603 | tickit/allevents_pipe.txt| 2013-02-08 21:04:14.785124
22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594
(12 rows)
```
事實上，記錄寫入至此系統檢視的日誌檔案，並不表示已成功遞交載入，做為其包含交易的一部分。若要驗證載入遞交，請查詢 STL\$1UTILITYTEXT 檢視，並尋找與 COPY 交易相對應的 COMMIT 記錄。例如，此查詢會針對 STL\$1UTILITYTEXT 根據子查詢聯結 SYS\$1LOAD\$1DETAIL 和 STL\$1QUERY：
```
select l.query_id,rtrim(l.file_name),q.transaction_id
from sys_load_detail l, sys_query_text q
where l.query_id=q.query_id
and exists
(select xid from stl_utilitytext where xid=q.transaction_id and rtrim("text")='COMMIT');
query_id | rtrim | transaction_id
----------+---------------------------+-----------------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
# SYS\$1LUDF\$1DETAIL
SYS\$1LUDF\$1DETAIL 會記錄在特定查詢中使用的 Lambda 使用者定義函數 (LUDFs) 的資訊和指標。
只有超級使用者可以看到 SYS\$1LUDF\$1DETAIL。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_LUDF_DETAIL.html)
## 範例查詢
下列範例在查詢中使用 Lambda UDF，然後顯示如何查詢 SYS\$1LUDF\$1DETAIL 檢視以查看函數執行詳細資訊。
```
SET SESSION AUTHORIZATION regular_user;
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT) RETURNS INT STABLE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
-- Switch to super user in order to inspect records in the LUDF SYS view.
SET SESSION AUTHORIZATION super_user;
select * from sys_ludf_detail;
```
輸出範例：
```
user_id | transaction_id | query_id | function_oid | function_position | stream_id | segment_id | step_id | lambda_function_name | start_time | end_time | total_duration | invocations | total_rows | input_bytes | output_bytes
---------+----------------+----------+--------------+-------------------+-----------+------------+---------+----------------------+----------------------------+----------------------------+----------------+-------------+------------+-------------+--------------
100 | 1463 | 1544 | 111055 | 0 | 0 | 0 | 2 | lambda_sum | 2026-01-06 17:23:25.165898 | 2026-01-06 17:23:25.165898 | 414 | 1 | 2 | 277 | 18
(1 row)
```
# SYS\$1LOAD\$1ERROR\$1DETAIL
使用 SYS\$1LOAD\$1ERROR\$1DETAIL 來檢視 COPY 命令錯誤的詳細資料。每一列代表一個 COPY 命令。它包含正在執行和已完成的 COPY 命令。
所有使用者都可看見 SYS\$1LOAD\$1ERROR\$1DETAIL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_LOAD_ERROR_DETAIL.html)
## 範例查詢
下列查詢會顯示特定查詢複製命令的載入錯誤詳細資訊。
```
SELECT query_id,
table_id,
start_time,
trim(file_name) AS file_name,
trim(column_name) AS column_name,
trim(column_type) AS column_type,
trim(error_message) AS error_message
FROM sys_load_error_detail
WHERE query_id = 762949
ORDER BY start_time
LIMIT 10;
```
輸出範例。
```
query_id | table_id | start_time | file_name | column_name | column_type | error_message
----------+----------+----------------------------+------------------------------------------+-------------+-------------+------------------------------------------------
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_000 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_001 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
```
# SYS\$1LOAD\$1HISTORY
使用 SYS\$1LOAD\$1HISTORY 來檢視 COPY 命令的詳細資訊。每一列代表一個 COPY 命令，其中包含某些欄位的累計統計資料。它包含正在執行和已完成的 COPY 命令。
所有使用者都可看見 SYS\$1LOAD\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_LOAD_HISTORY.html)
## 範例查詢
下列查詢顯示特定複製命令的載入列、位元組、資料表和資料來源。
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
WHERE query_id IN (6389,490791,441663,74374,72297)
ORDER BY query_id,
data_source DESC;
```
輸出範例。
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------+-----------------------------------------------------------------------+-------------+---------------
6389 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196240296158
72297 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
74374 | ship_mode | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/ship_mode/ | 20 | 1320
441663 | income_band | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/income_band/ | 20 | 2152
490791 | customer_address | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/customer_address/ | 6000000 | 722924305
```
下列查詢顯示複製命令的載入列、位元組、資料表和資料來源。
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
ORDER BY query_id DESC
LIMIT 10;
```
輸出範例。
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------------+-----------------------------------------------------------------------------+-------------+-----------------
491058 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
490947 | web_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_sales/ | 720000376 | 22971988122819
490923 | web_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_returns/ | 71997522 | 96597496325
490918 | web_page | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_page/ | 3000 | 1320
490907 | warehouse | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/warehouse/ | 20 | 1320
490902 | time_dim | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/time_dim/ | 86400 | 1320
490876 | store_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_sales/ | 2879987999 | 151666241887933
490870 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196405607941
490865 | store | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store/ | 1002 | 365507
```
下列查詢顯示複製命令的每日載入列和位元組。
```
SELECT date_trunc('day',start_time) AS exec_day,
SUM(loaded_rows) AS loaded_rows,
SUM(loaded_bytes) AS loaded_bytes
FROM sys_load_history
GROUP BY exec_day
ORDER BY exec_day DESC;
```
輸出範例。
```
exec_day | loaded_rows | loaded_bytes
---------------------+-------------+------------------
2022-01-20 00:00:00 | 6347386005 | 258329473070606
2022-01-19 00:00:00 | 19042158015 | 775198502204572
2022-01-18 00:00:00 | 38084316030 | 1550294469446883
2022-01-17 00:00:00 | 25389544020 | 1033271084791724
2022-01-16 00:00:00 | 19042158015 | 775222736252792
2022-01-15 00:00:00 | 19834245387 | 798122849155598
2022-01-14 00:00:00 | 75376544688 | 3077040926571384
```
# SYS\$1MV\$1REFRESH\$1HISTORY
結果包括所有具體化視觀表之重新整理歷史記錄的相關資訊。結果包括重新整理類型 (例如手動或自動)，以及最近重新整理的狀態。
所有使用者都可看見 SYS\$1MV\$1REFRESH\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_MV_REFRESH_HISTORY.html)
## 範例查詢
下列查詢顯示具體化視觀表的重新整理歷史記錄。
```
SELECT user_id,
session_id,
transaction_id,
database_name,
schema_name,
mv_id,
mv_name,
refresh_type,
status,
start_time,
end_time,
duration,
consumer_account,
consumer_region,
consumer_namespace
from sys_mv_refresh_history;
```
此查詢會傳回下列範例輸出：
```
user_id | session_id | transaction_id | database_name | schema_name | mv_id | mv_name | refresh_type | status | start_time | end_time | duration | consumer_account | consumer_region | consumer_namespace
---------+------------+----------------+---------------+----------------------------+--------+--------------------+----------------+------------------------------------------------------------------------------------------------------+----------------------------+----------------------------+-----------+------------------+-----------------+------------------------------------
1 | 1073815659 | 15066 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | MV was already updated | 2023-10-26 15:59:20.952179 | 2023-10-26 15:59:20.952866 | 687 | | |
1 | 1073815659 | 15068 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | MV was already updated | 2023-10-26 15:59:21.008049 | 2023-10-26 15:59:21.008658 | 609 | | |
1 | 1073815659 | 15070 | ext_db | producer_schema | 203779 | producer_mv | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:21.064252 | 2023-10-26 15:59:21.064885 | 633 | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af
1 | 1073815659 | 15074 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:29.693329 | 2023-10-26 15:59:43.482842 | 13789513 | | |
1 | 1073815659 | 15076 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | Refresh successfully recomputed MV from scratch | 2023-10-26 15:59:43.550184 | 2023-10-26 15:59:47.880833 | 4330649 | | |
1 | 1073815659 | 15078 | dev | test_stl_mv_refresh_schema | 203779 | mv_refresh_error | Manual | Refresh failed due to an internal error | 2023-10-26 15:59:47.949052 | 2023-10-26 15:59:52.494681 | 4545629 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh failed because materialized view test_stl_mv_refresh_schema.child was not refreshed. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh skipped because materialized view test_stl_mv_refresh_schema.child was not refreshed.| 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
(10 rows)
```
# SYS\$1MV\$1STATE
結果包括所有具體化視觀表狀態的相關資訊。它包括基底資料表資訊、結構描述屬性，以及有關最近事件的資訊，例如卸除欄。
所有使用者都可看見 SYS\$1MV\$1STATE。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_MV_STATE.html)
## 範例查詢
下列查詢顯示具體化視觀表的狀態。
```
select * from sys_mv_state;
```
此查詢會傳回下列範例輸出：
```
user_id | transaction_id | database_name | event_desc | start_time | base_table_database_name | base_table_schema | base_table_name | mv_schema | mv_name | state
---------+----------------+---------------+-----------------------------+----------------------------+--------------------------+-------------------+---------------------+-------------+----------------------------+--------------
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788268 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Recompute
106 | 12724 | tickit_db | ALTER TABLE ALTER DISTSTYLE | 2023-07-26 14:59:51.409014 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.822928 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051244 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857755 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051358 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788159 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857799 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788327 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Recompute
106 | 12727 | tickit_db | ALTER TABLE ALTER SORTKEY | 2023-07-26 15:00:08.006235 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.82297 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051321 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
```
# SYS\$1PROCEDURE\$1CALL
使用 SYS\$1PROCEDURE\$1CALL 檢視來取得預存程序呼叫的相關資訊，包括開始時間、結束時間、預存程序呼叫的狀態，以及巢狀預存程序呼叫的呼叫階層。每次預存程序呼叫會接收查詢 ID。
所有使用者都可看見 SYS\$1PROCEDURE\$1CALL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_PROCEDURE_CALL.html)
## 範例查詢
下列查詢會傳回巢狀預存程序呼叫階層。
```
select query_id, datediff(seconds, start_time, end_time) as elapsed_time, status, trim(query_text) as call, caller_procedure_query_id from sys_procedure_call;
```
輸出範例。
```
query_id | elapsed_time | status | call | caller_procedure_query_id
----------+--------------+---------+--------------------------------------------------+---------------------------
3087 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d(1) | 3085
3085 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d_2(1); |
(2 rows)
```
# SYS\$1PROCEDURE\$1MESSAGES
所有使用者都可看見 SYS\$1PROCEDURE\$1MESSAGES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_PROCEDURE_MESSAGES.html)
## 範例查詢
下列查詢顯示 SYS\$1PROCEDURE\$1MESSAGES 的範例輸出。
```
select transaction_id, query_id, record_time, log_level, trim(message), line_number from sys_procedure_messages;
```
```
transaction_id | query_id | record_time | log_level | btrim | line_number
---------------+----------+----------------------------+-----------+---------------------------+-------------
25267 | 80562 | 2023-07-17 14:38:31.910136 | NOTICE | test_notice_msg_b9f1e749 | 8
25267 | 80562 | 2023-07-17 14:38:31.910002 | LOG | test_log_msg_833c7420 | 6
25267 | 80562 | 2023-07-17 14:38:31.910111 | INFO | test_info_msg_651373d9 | 7
25267 | 80562 | 2023-07-17 14:38:31.910154 | WARNING | test_warning_msg_831c5747 | 9
(4 rows)
```
# SYS\$1QUERY\$1DETAIL
使用 SYS\$1QUERY\$1DETAIL 來檢視各種指標層級的查詢詳細資訊，其中每一列代表特定指標層級的特定 WLM 查詢的詳細資訊。此檢視包含許多類型的查詢，例如 DDL、DML 和公用程式命令 (例如，複製和卸載)。根據查詢類型的不同，某些欄可能不相關。例如，external\$1scanned\$1bytes 與內部資料表不相關。
所有使用者都可看見 SYS\$1QUERY\$1DETAIL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
若要驗證包含已執行查詢的交易是否已成功認可，您需要在系統資料表與 `sys_transaction_history` 資料表之間執行聯結操作。例如：
```
SELECT
th.transaction_id,
qd.query_id,
th.status AS transaction_status
FROM
sys_query_detail qd
LEFT JOIN sys_query_history qh ON qd.query_id = qh.query_id
LEFT JOIN sys_transaction_history th on qh.transaction_id = th.transaction_id;
```
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## 使用須知
SYS\$1QUERY\$1DETAIL 可包含步驟、串流、區段和子查詢層級的指標。除了參考 metrics\$1level 欄之外，您還可以根據下表參考 step\$1id、segment\$1id 和 stream\$1id 欄位，以查看某一列顯示的指標層級。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## 範例查詢
下列範例會傳回 SYS\$1QUERY\$1DETAIL 的輸出。
以下查詢顯示步驟層級的查詢中繼資料詳細資訊，包括步驟名稱、input\$1bytes、output\$1bytes、input\$1rows、output\$1rows。
```
SELECT query_id,
child_query_sequence,
stream_id,
segment_id,
step_id,
trim(step_name) AS step_name,
duration,
input_bytes,
output_bytes,
input_rows,
output_rows
FROM sys_query_detail
WHERE query_id IN (193929)
ORDER BY query_id,
stream_id,
segment_id,
step_id DESC;
```
輸出範例。
```
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | duration | input_bytes | output_bytes | input_rows | output_rows
----------+----------------------+-----------+------------+---------+------------+-----------------+-------------+--------------+------------+-------------
193929 | 2 | 0 | 0 | 3 | hash | 37144 | 0 | 9350272 | 0 | 292196
193929 | 5 | 0 | 0 | 3 | hash | 9492 | 0 | 23360 | 0 | 1460
193929 | 1 | 0 | 0 | 3 | hash | 46809 | 0 | 9350272 | 0 | 292196
193929 | 4 | 0 | 0 | 2 | return | 7685 | 0 | 896 | 0 | 112
193929 | 1 | 0 | 0 | 2 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 2 | 0 | 0 | 2 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 2 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 2 | return | 11033 | 0 | 14336 | 0 | 112
193929 | 2 | 0 | 0 | 1 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 1 | 0 | 0 | 1 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 1 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 1 | aggregate | 11033 | 0 | 201488 | 0 | 14
193929 | 4 | 0 | 0 | 1 | aggregate | 7685 | 0 | 28784 | 0 | 14
193929 | 5 | 0 | 0 | 0 | scan | 9492 | 0 | 23360 | 292196 | 1460
193929 | 4 | 0 | 0 | 0 | scan | 7685 | 0 | 1344 | 112 | 112
193929 | 2 | 0 | 0 | 0 | scan | 37144 | 0 | 7304900 | 292196 | 292196
193929 | 3 | 0 | 0 | 0 | scan | 11033 | 0 | 13440 | 112 | 112
193929 | 1 | 0 | 0 | 0 | scan | 46809 | 0 | 7304900 | 292196 | 292196
193929 | 5 | 0 | 0 | -1 | | 9492 | 12288 | 0 | 0 | 0
193929 | 1 | 0 | 0 | -1 | | 46809 | 16384 | 0 | 0 | 0
193929 | 2 | 0 | 0 | -1 | | 37144 | 16384 | 0 | 0 | 0
193929 | 4 | 0 | 0 | -1 | | 7685 | 28672 | 0 | 0 | 0
193929 | 3 | 0 | 0 | -1 | | 11033 | 114688 | 0 | 0 | 0
```
若要檢視資料庫中的資料表，從最常用到最少使用的順序，請使用下列範例。用您自己的資料庫取代 *sample\$1data\$1dev*。請注意，此查詢將在建立叢集時開始計算查詢，但是當資料倉儲缺少空間時，系統檢視資料不會儲存。
```
SELECT table_name, COUNT (DISTINCT query_id)
FROM SYS_QUERY_DETAIL
WHERE table_name LIKE 'sample_data_dev%'
GROUP BY table_name
ORDER BY COUNT(*) DESC;
+---------------------------------+-------+
| table_name | count |
+---------------------------------+-------+
| sample_data_dev.tickit.venue | 4 |
| sample_data_dev.myunload1.venue | 3 |
| sample_data_dev.tickit.listing | 1 |
| sample_data_dev.tickit.category | 1 |
| sample_data_dev.tickit.users | 1 |
| sample_data_dev.tickit.date | 1 |
| sample_data_dev.tickit.sales | 1 |
| sample_data_dev.tickit.event | 1 |
+---------------------------------+-------+
```
下列範例顯示單一 WLM 查詢的各種指標層級。
```
SELECT query_id, child_query_sequence, stream_id, segment_id, step_id, step_name, start_time, end_time, metrics_level
FROM sys_query_detail
WHERE query_id = 1553 AND step_id = -1
ORDER BY stream_id, segment_id, step_id;
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | start_time | end_time | metrics_level
----------+----------------------+-----------+------------+---------+-----------+----------------------------+----------------------------+---------------
1553 | 1 | -1 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.847838 | child query
1553 | 1 | 0 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.835609 | stream
1553 | 1 | 0 | 0 | -1 | | 2024-10-17 02:28:49.824677 | 2024-10-17 02:28:49.830372 | segment
1553 | 1 | 1 | -1 | -1 | | 2024-10-17 02:28:49.835624 | 2024-10-17 02:28:49.845773 | stream
1553 | 1 | 1 | 1 | -1 | | 2024-10-17 02:28:49.84088 | 2024-10-17 02:28:49.842388 | segment
1553 | 1 | 1 | 2 | -1 | | 2024-10-17 02:28:49.835926 | 2024-10-17 02:28:49.844396 | segment
1553 | 1 | 2 | -1 | -1 | | 2024-10-17 02:28:49.846949 | 2024-10-17 02:28:49.847838 | stream
1553 | 1 | 2 | 3 | -1 | | 2024-10-17 02:28:49.847013 | 2024-10-17 02:28:49.847485 | segment
(8 rows)
```
# SYS\$1QUERY\$1EXPLAIN
顯示已提交供執行之用的查詢的 EXPLAIN 計劃。
所有使用者都可看見 SYS\$1QUERY\$1EXPLAIN。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_QUERY_EXPLAIN.html)
## 範例查詢
下列範例是單一查詢的 EXPLAIN 計畫。
```
SELECT * FROM sys_query_explain WHERE query_id = 612635 ORDER BY plan_node_id;
userid | query_id | child_query_sequence | plan_node_id | plan_parent_id | plan_node | plan_info
--------+----------+----------------------+--------------+----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 612635 | 1 | 1 | 0 | XN Limit (cost=3604047533041.00..3604047533041.25 rows=100 width=20) |
100 | 612635 | 1 | 2 | 1 | -> XN Merge (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Merge Key: sum(b.totalprice)
100 | 612635 | 1 | 3 | 2 | -> XN Network (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Send to leader
100 | 612635 | 1 | 4 | 3 | -> XN Sort (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Sort Key: sum(b.totalprice)
100 | 612635 | 1 | 5 | 4 | -> XN HashAggregate (cost=2604047529640.76..2604047529747.78 rows=42809 width=20) |
100 | 612635 | 1 | 6 | 5 | -> XN Hash Join DS_DIST_NONE (cost=15104956.16..2602364653507.34 rows=336575226684 width=20) | Hash Cond: (("outer".listid = "inner".listid) AND ("outer".sellerid = "inner".sellerid))
100 | 612635 | 1 | 7 | 6 | -> XN Seq Scan on listing b (cost=0.00..7884677.12 rows=788467712 width=24) |
100 | 612635 | 1 | 8 | 6 | -> XN Hash (cost=7063797.76..7063797.76 rows=706379776 width=8) |
100 | 612635 | 1 | 9 | 8 | -> XN Seq Scan on sales a (cost=0.00..7063797.76 rows=706379776 width=8) |
(9 rows)
```
# SYS\$1QUERY\$1HISTORY
使用 SYS\$1QUERY\$1HISTORY 來檢視使用者查詢的詳細資料。每一列代表一個使用者查詢，其中包含某些欄位的累計統計資料。此檢視包含許多類型的查詢，例如資料定義語言 (DDL)、資料處理語言 (DML)、複製、卸載和 Amazon Redshift Spectrum。它包含正在執行和已完成的查詢。
所有使用者都可看見 SYS\$1QUERY\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
**注意**
若要驗證包含已執行查詢的交易是否已成功認可，您需要在系統資料表與 `sys_transaction_history` 資料表之間執行聯結操作。例如：
```
SELECT
qh.transaction_id,
qh.query_id,
qh.status AS query_status,
qh.query_type,
TRIM(qh.query_text) AS query_text,
th.status AS transaction_status
FROM
sys_query_history qh
LEFT JOIN
sys_transaction_history th ON qh.transaction_id = th.transaction_id;
```
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_QUERY_HISTORY.html)
## 範例查詢
下列查詢會傳回執行中和佇列中的查詢。
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time
FROM sys_query_history
WHERE status IN ('running','queued')
ORDER BY start_time;
```
輸出範例。
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time
---------+----------+----------------+------------+---------+---------------+---------------------------+----------------------------+------------------+--------------+------------+----------------
101 | 760705 | 852337 | 1073832321 | running | tpcds_1t | 2022-02-15 19:03:19.67849 | 2022-02-15 19:03:19.739811 | f | 61321 | 0 | 0
```
下列查詢會傳回特定查詢的查詢開始時間、結束時間、佇列時間、經歷時間、計劃時間及其他中繼資料。
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time,
planning_time,
trim(query_text) as query_text
FROM sys_query_history
WHERE query_id = 3093;
```
輸出範例。
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time | planning_time | query_text
--------+----------+----------------+------------+------------+---------------+----------------------------+----------------------------+------------------+--------------+------------+----------------+---------------+-------------------------------------
106 | 3093 | 11759 | 1073750146 | success | dev | 2023-03-16 16:53:17.840214 | 2023-03-16 16:53:18.106588 | f | 266374 | 0 | 105725 | 136589 | select count(*) from item;
```
下列查詢會列出10 個最近的 SELECT 查詢。
```
SELECT query_id,
transaction_id,
session_id,
start_time,
elapsed_time,
queue_time,
execution_time,
returned_rows,
returned_bytes
FROM sys_query_history
WHERE query_type = 'SELECT'
ORDER BY start_time DESC limit 10;
```
輸出範例。
```
query_id | transaction_id | session_id | start_time | elapsed_time | queue_time | execution_time | returned_rows | returned_bytes
----------+----------------+------------+----------------------------+--------------+------------+----------------+---------------+----------------
526532 | 61093 | 1073840313 | 2022-02-09 04:43:24.149603 | 520571 | 0 | 481293 | 1 | 3794
526520 | 60850 | 1073840313 | 2022-02-09 04:38:27.24875 | 635957 | 0 | 596601 | 1 | 3679
526508 | 60803 | 1073840313 | 2022-02-09 04:37:51.118835 | 563882 | 0 | 503135 | 5 | 17216
526505 | 60763 | 1073840313 | 2022-02-09 04:36:48.636224 | 649337 | 0 | 589823 | 1 | 652
526478 | 60730 | 1073840313 | 2022-02-09 04:36:11.741471 | 14611321 | 0 | 14544058 | 0 | 0
526467 | 60636 | 1073840313 | 2022-02-09 04:34:11.91463 | 16711367 | 0 | 16633767 | 1 | 575
511617 | 617946 | 1074009948 | 2022-01-20 06:21:54.44481 | 9937090 | 0 | 9899271 | 100 | 12500
511603 | 617941 | 1074259415 | 2022-01-20 06:21:45.71744 | 8065081 | 0 | 7582500 | 100 | 8889
511595 | 617935 | 1074128320 | 2022-01-20 06:21:44.030876 | 1051270 | 0 | 1014879 | 1 | 72
511584 | 617931 | 1074030019 | 2022-01-20 06:21:42.764088 | 609033 | 0 | 485887 | 100 | 8438
```
下列查詢會顯示每日選擇查詢計數和平均查詢經歷時間。
```
SELECT date_trunc('day',start_time) AS exec_day,
status,
COUNT(*) AS query_cnt,
AVG(datediff (microsecond,start_time,end_time)) AS elapsed_avg
FROM sys_query_history
WHERE query_type = 'SELECT'
AND start_time >= '2022-01-14'
AND start_time <= '2022-01-18'
GROUP BY exec_day,
status
ORDER BY exec_day,
status;
```
輸出範例。
```
exec_day | status | query_cnt | elapsed_avg
---------------------+---------+-----------+------------
2022-01-14 00:00:00 | success | 5253 | 56608048
2022-01-15 00:00:00 | success | 7004 | 56995017
2022-01-16 00:00:00 | success | 5253 | 57016363
2022-01-17 00:00:00 | success | 5309 | 55236784
2022-01-18 00:00:00 | success | 8092 | 54355124
```
下列查詢會顯示日常查詢的經歷時間效能。
```
SELECT distinct date_trunc('day',start_time) AS exec_day,
query_count.cnt AS query_count,
Percentile_cont(0.5) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P50_runtime,
Percentile_cont(0.8) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P80_runtime,
Percentile_cont(0.9) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P90_runtime,
Percentile_cont(0.99) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P99_runtime,
Percentile_cont(1.0) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS max_runtime
FROM sys_query_history
LEFT JOIN (SELECT date_trunc('day',start_time) AS day, count(*) cnt
FROM sys_query_history
WHERE query_type = 'SELECT'
GROUP by 1) query_count
ON date_trunc('day',start_time) = query_count.day
WHERE query_type = 'SELECT'
ORDER BY exec_day;
```
輸出範例。
```
exec_day | query_count | p50_runtime | p80_runtime | p90_runtime | p99_runtime | max_runtime
---------------------+-------------+-------------+-------------+-------------+--------------+--------------
2022-01-14 00:00:00 | 5253 | 16816922.0 | 69525096.0 | 158524917.8 | 486322477.52 | 1582078873.0
2022-01-15 00:00:00 | 7004 | 15896130.5 | 71058707.0 | 164314568.9 | 500331542.07 | 1696344792.0
2022-01-16 00:00:00 | 5253 | 15750451.0 | 72037082.2 | 159513733.4 | 480372059.24 | 1594793766.0
2022-01-17 00:00:00 | 5309 | 15394513.0 | 68881393.2 | 160254700.0 | 493372245.84 | 1521758640.0
2022-01-18 00:00:00 | 8092 | 15575286.5 | 68485955.4 | 154559572.5 | 463552685.39 | 1542783444.0
2022-01-19 00:00:00 | 5860 | 16648747.0 | 72470482.6 | 166485138.2 | 492038228.67 | 1693483241.0
2022-01-20 00:00:00 | 1751 | 15422072.0 | 69686381.0 | 162315385.0 | 497066615.00 | 1439319739.0
2022-02-09 00:00:00 | 13 | 6382812.0 | 17616161.6 | 21197988.4 | 23021343.84 | 23168439.0
```
下列查詢顯示查詢類型分佈。
```
SELECT query_type,
COUNT(*) AS query_count
FROM sys_query_history
GROUP BY query_type
ORDER BY query_count DESC;
```
輸出範例。
```
query_type | query_count
------------+-------------
UTILITY | 134486
SELECT | 38537
DDL | 4832
OTHER | 768
LOAD | 768
CTAS | 748
COMMAND | 92
```
下列範例顯示數個查詢之間查詢雜湊結果的差異。請觀察下列查詢：
```
CREATE TABLE test_table (col1 INT);
INSERT INTO test_table VALUES (1),(2);
SELECT * FROM test_table;
SELECT * FROM test_table;
SELECT col1 FROM test_table;
SELECT * FROM test_table WHERE col1=1;
SELECT * FROM test_table WHERE col1=2;
SELECT query_id, TRIM(user_query_hash) AS user_query_hash, TRIM(generic_query_hash) AS generic_query_hash, TRIM(query_text) AS text FROM sys_query_history ORDER BY start_time
DESC LIMIT 10;
```
以下是範例輸出：
```
query_id | user_query_hash | generic_query_hash | text
---------+-----------------+--------------------+----------
24723049 | oPuFtjEPLTs= | oPuFtjEPLTs= | select query_id, trim(user_query_hash) as user_query_hash, trim(generic_query_hash) as generic_query_hash, query_hash_version, trim(query_text) as text from sys_query_history order by start_time\r\ndesc limit 20
24723045 | Gw2Kwdd8m2I= | IwfRu8/XAKI= | select * from test_table where col1=2 limit 100
24723041 | LNw2vx0GDXo= | IwfRu8/XAKI= | select * from test_table where col1=1 limit 100
24723036 | H+qep/c82Y8= | H+qep/c82Y8= | select col1 from test_table limit 100
24723033 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723029 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723023 | 50sirx9E1hU= | uO36Z1a/QYs= | insert into test_table values (1),(2)
24723021 | YSVnlivZHeo= | YSVnlivZHeo= | create table test_table (col1 int)
```
`SELECT * FROM test_table;` 和 `SELECT col1 FROM test_table;` 具有相同的 user\$1query\$1hash 值，因為 test\$1table 只有一欄。`SELECT * FROM test_table WHERE col1=1;` 和 `SELECT * FROM test_table WHERE col1=2;` 具有不同的 user\$1query\$1hash 值，但具有相同的 generic\$1query\$1hash 值，因為兩個查詢除了查詢常值 1 和 2 之外完全一致。
# SYS\$1QUERY\$1TEXT
使用 SYS\$1QUERY\$1TEXT 來檢視所有查詢的查詢文字。每一列代表查詢的查詢文字，最多 4000 個字元，以序列號 0 開始。當查詢陳述式包含超過 4000 個字元時，會藉由遞增每個列的序號來記錄陳述式的其他列。此檢視會記錄所有使用者查詢文字，例如 DDL、公用程式、Amazon Redshift 查詢，以及僅限潛在客戶節點的查詢。
所有使用者都可看見 SYS\$1QUERY\$1TEXT。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_QUERY_TEXT.html)
## 範例查詢
下列查詢會傳回執行中和佇列中的查詢。
```
SELECT user_id,
query_id,
transaction_id,
session_id, start_time,
sequence, trim(text) as text from sys_query_text
ORDER BY sequence;
```
輸出範例。
```
user_id | query_id | transaction_id | session_id | start_time | sequence | text
--------+----------+-----------------+------------+----------------------------+----------+----------------------------------------------------------------------------------------------------------------------
100 | 4 | 1396 | 1073750220 | 2023-04-28 16:44:55.887184 | 0 | SELECT trim(text) as text, sequence FROM sys_query_text WHERE query_id = pg_last_query_id() AND user_id > 1 AND start
_time > '2023-04-28 16:44:55.922705+00:00'::timestamp order by sequence;
```
下列查詢會傳回已從資料庫中的群組授與或撤銷的許可。
```
SELECT
SPLIT_PART(text, ' ', 1) as grantrevoke,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'GROUP'))), ' ', 2) as group,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), ' '))), 'ON', 1) as type,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 2) || ' ' || SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 3) as entity
FROM SYS_QUERY_TEXT
WHERE (text LIKE 'GRANT%' OR text LIKE 'REVOKE%') AND text LIKE '%GROUP%';
+-------------+----------+--------+----------+
| grantrevoke | group | type | entity |
+-------------+----------+--------+----------+
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | USAGE | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
+-------------+----------+--------+----------+
```
# SYS\$1REDSHIFT\$1TEMPLATE
使用 SYS\$1REDSHIFT\$1TEMPLATE 來檢視 Redshift TEMPLATES 的詳細資訊。
此檢視包含已建立的 TEMPLATES。
所有使用者都可看見 SYS\$1REDSHIFT\$1TEMPLATE。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_REDSHIFT_TEMPLATE.html)
## 範例查詢
下列查詢會傳回目前使用者可見的所有範本：
```
SELECT * FROM SYS_REDSHIFT_TEMPLATE;
```
輸出範例。
```
database_name | schema_name | template_name | template_type | create_time | last_modified_time | owner_id | last_modified_by | template_parameters
---------------+-------------+--------------------+---------------+----------------------------+----------------------------+----------+------------------+---------------------
dev | s1 | shapefile_template | 1 | 2025-12-17 22:42:02.079758 | 2025-12-17 22:42:02.079758 | 101 | 101 | {
"SIMPLIFY_AUTO": 0.000001,
"SHAPEFILE": 1,
"COMPRESSION_UPDATE": 0
}
dev | s2 | orc_template | 1 | 2025-12-17 22:42:23.582815 | 2025-12-17 22:42:23.582815 | 101 | 101 | {
"ORC": "serializetojson_default"
}
dev | s1 | csv_template | 1 | 2025-12-17 22:43:01.822361 | 2025-12-17 22:43:01.822361 | 101 | 101 | {
"ENCRYPTED": 1,
"CSV": 1,
"ENCODING": 1,
"DELIMITER": ","
}
(3 rows)
```
# SYS\$1RESTORE\$1LOG
使用 SYS\$1RESTORE\$1LOG 在傳統調整為 RA3 節點大小期間，監控叢集中每個資料表的遷移進度。它會在調整大小作業期間擷取資料遷移的歷史輸送量。如需有關傳統調整為 RA3 節點大小的詳細資訊，請參閱[傳統調整大小](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
只有超級使用者才能看到 SYS\$1RESTORE\$1LOG。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_RESTORE_LOG.html)
## 範例查詢
下列查詢會使用 SYS\$1RESTORE\$1LOG 計算資料處理的輸送量。
```
SELECT
ROUND(sum(delta_data_processed) / 1024.0, 2) as data_processed_gb,
ROUND(datediff(sec, min(event_time), max(event_time)) / 3600.0, 2) as duration_hr,
ROUND(data_processed_gb/duration_hr, 2) as throughput_gb_per_hr
from sys_restore_log;
```
輸出範例。
```
data_processed_gb | duration_hr | throughput_gb_per_hr
-------------------+-------------+----------------------
0.91 | 8.37 | 0.11
(1 row)
```
下列查詢顯示所有重新分佈類型。
```
SELECT * from sys_restore_log ORDER BY event_time;
```
```
database_name | schema_name | table_name | table_id | action | total_data_processed | delta_data_processed | event_time | table_size | message | redistribution_type
---------------+----------------------+----------------------+----------+-----------------------------+----------------------+----------------------+----------------------------+------------+---------+--------------------------
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution started | 0 | | 2024-01-05 02:18:00.744977 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution started | 0 | | 2024-01-05 02:18:02.756675 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution completed | 90 | 90 | 2024-01-05 02:23:30.643718 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution completed | 325 | 325 | 2024-01-05 02:23:45.998249 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution started | 0 | | 2024-01-05 02:23:46.083849 | 30 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution started | 0 | | 2024-01-05 02:23:46.855728 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution completed | 45 | 45 | 2024-01-05 02:24:16.343029 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution completed | 30 | 30 | 2024-01-05 02:24:20.584703 | 30 | | Rebalance Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution started | 0 | | 2024-01-05 04:54:55.641741 | 190 | | Restore Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution checkpointed | 29.4342113157737 | 29.4342113157737 | 2024-01-05 04:55:04.770696 | 190 | | Restore Disteven Table
(8 rows)
```
# SYS\$1RESTORE\$1STATE
使用 SYS\$1RESTORE\$1STATE 可以在傳統調整大小時監視每個資料表的移轉進度。當目標節點類型為 RA3 時，這特別適用。如需有關傳統調整為 RA3 節點大小的詳細資訊，請參閱[傳統調整大小](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster)。
只有超級使用者才能看到 SYS\$1RESTORE\$1STATE。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_RESTORE_STATE.html)
## 範例查詢
下列查詢會傳回執行中和佇列中查詢的記錄。
```
SELECT * FROM sys_restore_state;
```
輸出範例。
```
userid | database_name | schema_id | table_id | table_name | redistribution_status | precentage_redistributed | redistribution_type
--------+---------------+-----------+----------+----------------+-----------------------+--------------------------+-------------------------
1 | test1 | 124865 | 124878 | customer_key_4 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124874 | customer_key_3 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124870 | customer_key_2 | Completed | 100 | Rebalance Disteven Table
1 | dev | 124865 | 124866 | customer_key_1 | In progress | 13.52 | Restore Distkey Table
```
以下提供資料處理狀態。
```
SELECT
redistribution_status, ROUND(SUM(block_count) / 1024.0, 2) AS total_size_gb
FROM sys_restore_state sys inner join stv_tbl_perm stv
on sys.table_id = stv.id
GROUP BY sys.redistribution_status;
```
輸出範例。
```
redistribution_status | total_size_gb
-----------------------+---------------
Completed | 0.07
Pending | 0.71
In progress | 0.20
(3 rows)
```
# SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
超過結構描述配額時，記錄出現次數、交易 ID 和其他有用的資訊。此系統資料表為 [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md) 的翻譯。
所有使用者都可看見 r\$1SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_SCHEMA_QUOTA_VIOLATIONS.html)
## 範例查詢
下列查詢顯示配額違規的結果：
```
SELECT user_id, TRIM(schema_name) "schema_name", quota, disk_usage, record_time FROM
sys_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC;
```
此查詢會傳回所指定結構描述的下列範例輸出：
```
user_id| schema_name | quota | disk_usage | record_time
-------+--------------+-------+------------+----------------------------
104 | sales_schema | 2048 | 2798 | 2020-04-20 20:09:25.494723
(1 row)
```
# SYS\$1SERVERLESS\$1USAGE
使用 SYS\$1SERVERLESS\$1USAGE 來檢視 Amazon Redshift Serverless 資源使用情況的詳細資訊。此系統檢視不適用於已佈建的 Amazon Redshift 叢集。
此檢視包含無伺服器使用量摘要，包括使用多少運算容量來處理查詢，以及使用的 Amazon Redshift 託管儲存量 (1 分鐘精細程度)。運算容量以 Redshift 處理單元 (RPU) 為單位進行測量，並以每秒 RPU 秒為單位執行的工作負載進行計量。RPU 用於處理對資料倉儲中載入的資料的查詢、從 Amazon S3 資料湖查詢或使用聯合查詢從操作資料庫存取的資料。Amazon Redshift 伺服器會在 SYS\$1SERVERLESS\$1USAGE 中保留 7 天的資訊。
如需運算成本帳單的範例，請參閱 [Amazon Redshift Serverless 的計費](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html)。
只有超級使用者才能看到 SYS\$1SERVERLESS\$1USAGE。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_SERVERLESS_USAGE.html)
## 使用須知
+ 在某些情況下，compute\$1seconds 為 0，但 charged\$1seconds 大於 0，反之亦然。這是由於在系統檢視中記錄資料的方式所產生的正常行為。若要更準確地呈現無伺服器使用情況詳細資訊，我們建議您彙總資料。
## 範例
若要透過查詢 charged\$1seconds 來取得某個時間間隔內使用的 RPU 小時總費用，請執行下列查詢：
```
select trunc(start_time) "Day",
(sum(charged_seconds)/3600::double precision) * as cost_incurred
from sys_serverless_usage
group by 1
order by 1
```
請注意，間隔期間可能會有閒置時間。閒置時間不會增加至使用的 RPU。
# SYS\$1SESSION\$1HISTORY
使用 SYS\$1SESSION\$1HISTORY 來檢視目前作用中工作階段和工作階段歷史記錄的相關資訊。
所有使用者都可看見 SYS\$1SESSION\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_SESSION_HISTORY.html)
### 範例
下列為 SYS\$1SESSION\$1HISTORY 的範例輸出。
```
select * from sys_session_history;
user_id | session_id | database_name | status | session_timeout | start_time | end_time
---------+------------+------------------+--------+-----------------+----------------------------+----------------------------
1 | 1073971370 | dev | closed | 0 | 2023-07-17 15:50:12.030104 | 2023-07-17 15:50:12.123218
1 | 1073979694 | dev | closed | 0 | 2023-07-17 15:50:24.117947 | 2023-07-17 15:50:24.131859
1 | 1073873049 | dev | closed | 0 | 2023-07-17 15:49:29.067398 | 2023-07-17 15:49:29.070294
1 | 1073873086 | database18127a4a | closed | 0 | 2023-07-17 15:49:29.119018 | 2023-07-17 15:49:29.125925
1 | 1073832112 | dev | closed | 0 | 2023-07-17 15:49:29.164688 | 2023-07-17 15:49:29.179631
1 | 1073987697 | dev | closed | 0 | 2023-07-17 15:49:29.26749 | 2023-07-17 15:49:29.273034
1 | 1073922429 | dev | closed | 0 | 2023-07-17 15:49:33.35315 | 2023-07-17 15:49:33.367499
1 | 1073766783 | dev | closed | 0 | 2023-07-17 15:49:45.38237 | 2023-07-17 15:49:45.396902
1 | 1073807506 | dev | active | 0 | 2023-07-17 15:51:48 |
```
# SYS\$1SPATIAL\$1SIMPLIFY
您可以使用 COPY 命令查詢系統檢視 SYS\$1SPATIAL\$1SIMPLIFY，以取得有關簡化空間幾何物件的資訊。當您在 Shapefile 上使用 COPY 時，您可以指定 SIMPLIFY `tolerance`、SIMPLIFY AUTO 和 SIMPLIFY AUTO `max_tolerance` 擷取選項。簡化的結果摘要在 SYS\$1SPATIAL\$1SIMPLIFY 系統檢視中。
設定 SIMPLIFY AUTO `max_tolerance` 時，此檢視會針對超出大小上限的每個幾何包含一列。設定 SIMPLIFY `tolerance` 時，會儲存整個 COPY 操作的一個列。此列參考 COPY 查詢 ID 和指定的簡化公差。
如需有關載入 shapefile 的相關資訊，請參閱[將 Shapefile 載入 Amazon Redshift](spatial-copy-shapefile.md)。
所有使用者都可看見 SYS\$1SPATIAL\$1SIMPLIFY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_SPATIAL_SIMPLIFY.html)
## 範例查詢
下列查詢會傳回 COPY 簡化的記錄清單。
```
SELECT * FROM sys_spatial_simplify;
query_id | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
----------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
# SYS\$1STREAM\$1SCAN\$1ERRORS
記錄透過串流擷取載入之記錄的錯誤。
所有使用者都可看見 SYS\$1STREAM\$1SCAN\$1ERRORS。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html)
# SYS\$1STREAM\$1SCAN\$1STATES
記錄透過串流擷取載入之記錄的掃描狀態。
所有使用者都可看見 SYS\$1STREAM\$1SCAN\$1STATES。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_SYS_STREAM_SCAN_STATES.html)
下列查詢會顯示特定查詢的串流和主題資料。
```
select query_id,mv_name::varchar,external_schema_name::varchar,stream_name::varchar,sum(scanned_rows) total_records,
sum(scanned_bytes) total_bytes from sys_stream_scan_states where query in (5401180,8601939) group by 1,2,3,4;
query_id | mv_name | external_schema_name | stream_name | total_records | total_bytes
------------+----------------+----------------------+-----------------+---------------+----------------
5401180 | kinesistest | kinesis | kinesisstream | 1493255696 | 3209006490704
8601939 | msktest | msk | mskstream | 14677023 | 31056580668
(2 rows)
```
# SYS\$1TRANSACTION\$1HISTORY
追蹤查詢時，請使用 SYS\$1TRANSACTION\$1HISTORY 來查看交易的詳細資訊。
只有超級使用者才能看到 SYS\$1TRANSACTION\$1HISTORY。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_TRANSACTION_HISTORY.html)
## 範例查詢
```
select * from sys_transaction_history order by transaction_start_time desc;
user_id | transaction_id | isolation_level | status | transaction_start_time | commit_start_time | commit_end_time | blocks_committed | undo_transaction_id
---------+----------------+-----------------+------------+----------------------------+----------------------------+----------------------------+------------------+---------------------
100 | 1310 | Serializable | committed | 2023-08-27 21:03:11.822205 | 2023-08-28 21:03:11.825287 | 2023-08-28 21:03:11.854883 | 17 | -1
101 | 1345 | Serializable | committed | 2023-08-27 21:03:12.000278 | 2023-08-28 21:03:12.003736 | 2023-08-28 21:03:12.030061 | 17 | -1
102 | 1367 | Serializable | committed | 2023-08-27 21:03:12.1532 | 2023-08-28 21:03:12.156124 | 2023-08-28 21:03:12.186468 | 17 | -1
100 | 1370 | Serializable | committed | 2023-08-27 21:03:12.199316 | 2023-08-28 21:03:12.204854 | 2023-08-28 21:03:12.238186 | 24 | -1
100 | 1408 | Serializable | committed | 2023-08-27 21:03:53.891107 | 2023-08-28 21:03:53.894825 | 2023-08-28 21:03:53.927465 | 17 | -1
100 | 1409 | Serializable | rolledback | 2023-08-27 21:03:53.936431 | 2000-01-01 00:00:00 | 2023-08-28 21:04:08.712532 | 0 | 1409
101 | 1415 | Serializable | committed | 2023-08-27 21:04:24.283188 | 2023-08-28 21:04:24.289196 | 2023-08-28 21:04:24.374318 | 25 | -1
101 | 1416 | Serializable | committed | 2023-08-27 21:04:24.38818 | 2023-08-28 21:04:24.391688 | 2023-08-28 21:04:24.415135 | 17 | -1
100 | 1417 | Serializable | rolledback | 2023-08-27 21:04:24.424252 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.354826 | 0 | 1417
101 | 1418 | Serializable | rolledback | 2023-08-27 21:04:24.425195 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.680355 | 0 | 1418
100 | 1420 | Serializable | committed | 2023-08-27 21:04:28.697607 | 2023-08-28 21:04:28.702374 | 2023-08-28 21:04:28.735541 | 23 | -1
101 | 1421 | Serializable | committed | 2023-08-27 21:04:28.744854 | 2023-08-28 21:04:28.749344 | 2023-08-28 21:04:28.779029 | 23 | -1
101 | 1423 | Serializable | committed | 2023-08-27 21:04:28.78942 | 2023-08-28 21:04:28.791556 | 2023-08-28 21:04:28.817485 | 16 | -1
100 | 1430 | Serializable | committed | 2023-08-27 21:04:28.917788 | 2023-08-28 21:04:28.919993 | 2023-08-28 21:04:28.944812 | 16 | -1
102 | 1494 | Serializable | committed | 2023-08-27 21:04:37.029058 | 2023-08-28 21:04:37.033137 | 2023-08-28 21:04:37.062001 | 16 | -1
```
# SYS\$1UDF\$1LOG
使用者定義函數 (UDF) 執行期間產生的記錄系統定義的錯誤和警告訊息。
只有超級使用者才能看到 SYS\$1UDF\$1LOG。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_UDF_LOG.html)
## 範例查詢
以下範例說明 UDF 如何處理系統定義的錯誤。第一個區塊顯示傳回引數反向之 UDF 函數的定義。當您執行函數並提供 0 做為引數時，函數會傳回錯誤。最後一個陳述式會傳回 SYS\$1UDF\$1LOG 中記錄的錯誤訊息。
```
-- Create a function to find the inverse of a number.
CREATE OR REPLACE FUNCTION f_udf_inv(a int)
RETURNS float
IMMUTABLE AS $$return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to create an error.
Select f_udf_inv(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------
2211 | 2023-08-23 15:53:11.360538 | ZeroDivisionError: integer division or modulo by zero line 2, in f_udf_inv\n return 1/a\n
```
下列範例會將記錄且警告訊息新增至 UDF，以至於除以零操作會導致警告訊息，而不是停止並出現錯誤訊息。
```
-- Create a function to find the inverse of a number and log a warning if you input 0.
CREATE OR REPLACE FUNCTION f_udf_inv_log(a int)
RETURNS float IMMUTABLE
AS $$
import logging
logger = logging.getLogger() #get root logger
if a==0:
logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n')
return 0
else:
return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to trigger the warning.
Select f_udf_inv_log(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------------------------------
0 | 2023-08-23 16:10:48.833503 | WARNING: You attempted to divide by zero.\nReturning zero instead of error.\n
```
# SYS\$1UNLOAD\$1DETAIL
使用 SYS\$1UNLOAD\$1DETAIL 來檢視 UNLOAD 操作的詳細資訊。它會針對 UNLOAD 陳述式所建立的每一個檔案各記錄一列。例如，若 UNLOAD 建立 12 個檔案，則 SYS\$1UNLOAD\$1DETAIL 將包含 12 個對應列。
所有使用者都可看見 SYS\$1UNLOAD\$1DETAIL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_UNLOAD_DETAIL.html)
## 範例查詢
下列查詢顯示卸載查詢詳細資訊，包括卸載命令的格式、列和檔案計數。
```
select query_id, substring(file_name, 0, 50), transfer_size, file_format from sys_unload_detail;
```
輸出範例。
```
query_id | substring | transfer_size | file_format
----------+-------------------------------------------------------------+---------------+-------------
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0000_part_00.gz | 395886 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0001_part_00.gz | 406444 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0002_part_00.gz | 409431 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0003_part_00.gz | 403051 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0004_part_00.gz | 413592 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0005_part_00.gz | 395689 | Text
(6 rows)
```
# SYS\$1UNLOAD\$1HISTORY
使用 SYS\$1UNLOAD\$1HISTORY 來檢視 UNLOAD 命令的詳細資訊。每一列代表一個 UNLOAD 命令，其中包含某些欄位的累計統計資料。它包含正在執行和已完成的 UNLOAD 命令。
所有使用者都可看見 SYS\$1UNLOAD\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_UNLOAD_HISTORY.html)
## 範例查詢
下列查詢顯示卸載查詢詳細資訊，包括卸載命令的格式、列和檔案計數。
```
SELECT query_id,
file_format,
start_time,
duration,
unloaded_rows,
unloaded_files_count
FROM sys_unload_history
ORDER BY query_id,
file_format limit 100;
```
輸出範例。
```
query_id | file_format | start_time | duration | unloaded_rows | unloaded_files_count
----------+-------------+----------------------------+----------+---------------+----------------------
527067 | Text | 2022-02-09 05:18:35.844452 | 5932478 | 10 | 1
```
# SYS\$1USERLOG
記錄資料庫使用者之下列變更的詳細資訊：
+ 建立使用者
+ 捨棄使用者
+ 更改使用者 (重新命名)
+ 更改使用者 (更改屬性)
您可以查詢此檢視，以查看有關無伺服器工作群組和已佈建叢集的資訊。
只有超級使用者才能看到 SYS\$1USERLOG。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_USERLOG.html)
## 範例查詢
下列範例會執行四個使用者動作，然後查詢 SYS\$1USERLOG 資料表。
```
CREATE USER userlog1 password 'Userlog1';
ALTER USER userlog1 createdb createuser;
ALTER USER userlog1 rename to userlog2;
DROP user userlog2;
SELECT user_id, user_name, original_user_name, action, has_create_db_privs, is_superuser from SYS_USERLOG order by record_time desc;
```
```
user_id | user_name | original_user_name | action | has_create_db_privs | is_superuser
--------+------------+--------------------+---------+---------------------+------------
108 | userlog2 | | drop | 1 | 1
108 | userlog2 | userlog1 | rename | 1 | 1
108 | userlog1 | | alter | 1 | 1
108 | userlog1 | | create | 0 | 0
(4 rows)
```
# SYS\$1VACUUM\$1HISTORY
使用 SYS\$1VACUUM\$1HISTORY 來檢視清空查詢的詳細資料。如需 VACUUM 命令的詳細資訊，請參閱[VACUUM](r_VACUUM_command.md)。
所有使用者都可看見 SYS\$1VACUUM\$1HISTORY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/SYS_VACUUM_HISTORY.html)
# 移轉至 SYS 監控檢視的系統檢視映射
將 Amazon Redshift 佈建叢集遷移到 Amazon Redshift Serverless 時，您的監控或診斷查詢可能會參考僅在已佈建叢集上可用的系統檢視。您可以更新查詢以使用 SYS 監控檢視。此頁面提供僅限佈建的 SYS 檢視映射，供您在更新查詢時參考。
**Topics**
+ [
## SYS\$1QUERY\$1HISTORY
](#sys_view_migration-SYS_QUERY_HISTORY)
+ [
## SYS\$1QUERY\$1DETAIL
](#sys_view_migration-SYS_QUERY_DETAIL)
+ [
## SYS\$1RESTORE\$1LOG
](#sys_view_migration-SYS_RESTORE_LOG)
+ [
## SYS\$1RESTORE\$1STATE
](#sys_view_migration-SYS_RESTORE_STATE)
+ [
## SYS\$1TRANSACTION\$1HISTORY
](#sys_view_migration-SYS_TRANSACTION_HISTORY)
+ [
## SYS\$1QUERY\$1TEXT
](#sys_view_migration-SYS_QUERY_TEXT)
+ [
## SYS\$1CONNECTION\$1LOG
](#sys_view_migration-SYS_CONNECTION_LOG)
+ [
## SYS\$1SESSION\$1HISTORY
](#sys_view_migration-SYS_SESSION_HISTORY)
+ [
## SYS\$1LOAD\$1DETAIL
](#sys_view_migration-SYS_LOAD_DETAIL)
+ [
## SYS\$1LOAD\$1HISTORY
](#sys_view_migration-SYS_LOAD_HISTORY)
+ [
## SYS\$1LOAD\$1ERROR\$1DETAIL
](#sys_view_migration-SYS_LOAD_ERROR_DETAIL)
+ [
## SYS\$1UNLOAD\$1HISTORY
](#sys_view_migration-SYS_UNLOAD_HISTORY)
+ [
## SYS\$1UNLOAD\$1DETAIL
](#sys_view_migration-SYS_UNLOAD_DETAIL)
+ [
## SYS\$1COPY\$1REPLACEMENTS
](#sys_view_migration-SYS_COPY_REPLACEMENTS)
+ [
## SYS\$1DATASHARE\$1USAGE\$1CONSUMER
](#sys_view_migration-SYS_DATASHARE_USAGE_CONSUMER)
+ [
## SYS\$1DATASHARE\$1USAGE\$1PRODUCER
](#sys_view_migration-SYS_DATASHARE_USAGE_PRODUCER)
+ [
## SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
](#sys_view_migration-SYS_DATASHARE_CROSS_REGION_USAGE)
+ [
## SYS\$1DATASHARE\$1CHANGE\$1LOG
](#sys_view_migration-SYS_DATASHARE_CHANGE_LOG)
+ [
## SYS\$1EXTERNAL\$1QUERY\$1DETAIL
](#sys_view_migration-SYS_EXTERNAL_QUERY_DETAIL)
+ [
## SYS\$1EXTERNAL\$1QUERY\$1ERROR
](#sys_view_migration-SYS_EXTERNAL_QUERY_ERROR)
+ [
## SYS\$1VACUUM\$1HISTORY
](#sys_view_migration-SYS_VACUUM_HISTORY)
+ [
## SYS\$1ANALYZE\$1HISTORY
](#sys_view_migration-SYS_ANALYZE_HISTORY)
+ [
## SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
](#sys_view_migration-SYS_ANALYZE_COMPRESSION_HISTORY)
+ [
## SYS\$1MV\$1REFRESH\$1HISTORY
](#sys_view_migration-SYS_MV_REFRESH_HISTORY)
+ [
## SYS\$1MV\$1STATE
](#sys_view_migration-SYS_MV_STATE)
+ [
## SYS\$1PROCEDURE\$1CALL
](#sys_view_migration-SYS_PROCEDURE_CALL)
+ [
## SYS\$1PROCEDURE\$1MESSAGES
](#sys_view_migration-SYS_PROCEDURE_MESSAGES)
+ [
## SYS\$1UDF\$1LOG
](#sys_view_migration-SYS_UDF_LOG)
+ [
## SYS\$1USERLOG
](#sys_view_migration-SYS_USERLOG)
+ [
## SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
](#sys_view_migration-SYS_SCHEMA_QUOTA_VIOLATIONS)
+ [
## SYS\$1SPATIAL\$1SIMPLIFY
](#sys_view_migration-SYS_SPATIAL_SIMPLIFY)
## SYS\$1QUERY\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)中定義。
+ [STL\$1DDLTEXT](r_STL_DDLTEXT.md)
+ [STL\$1ERROR](r_STL_ERROR.md)
+ [STL\$1QUERY](r_STL_QUERY.md)
+ [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md)
+ [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md)
+ [STV\$1INFLIGHT](r_STV_INFLIGHT.md)
+ [STV\$1RECENTS](r_STV_RECENTS.md)
+ [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md)
+ [SVL\$1COMPILE](r_SVL_COMPILE.md)
+ [SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS](r_SVL_MULTI_STATEMENT_VIOLATIONS.md)
+ [SVL\$1QLOG](r_SVL_QLOG.md)
+ [SVL\$1QUERY\$1QUEUE\$1INFO](r_SVL_QUERY_QUEUE_INFO.md)
+ [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)
+ [SVL\$1TERMINATE](r_SVL_TERMINATE.md)
## SYS\$1QUERY\$1DETAIL
下列資料表中的部分或所有欄也會在 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)中定義。
+ [STL\$1AGGR](r_STL_AGGR.md)
+ [STL\$1ALERT\$1EVENT\$1LOG](r_STL_ALERT_EVENT_LOG.md)
+ [STL\$1BCAST](r_STL_BCAST.md)
+ [STL\$1DELETE](r_STL_DELETE.md)
+ [STL\$1DIST](r_STL_DIST.md)
+ [STL\$1EXPLAIN](r_STL_EXPLAIN.md)
+ [STL\$1HASH](r_STL_HASH.md)
+ [STL\$1HASHJOIN](r_STL_HASHJOIN.md)
+ [STL\$1INSERT](r_STL_INSERT.md)
+ [STL\$1LIMIT](r_STL_LIMIT.md)
+ [STL\$1MERGE](r_STL_MERGE.md)
+ [STL\$1MERGEJOIN](r_STL_MERGEJOIN.md)
+ [STL\$1NESTLOOP](r_STL_NESTLOOP.md)
+ [STL\$1PARSE](r_STL_PARSE.md)
+ [STL\$1PLAN\$1INFO](r_STL_PLAN_INFO.md)
+ [STL\$1PROJECT](r_STL_PROJECT.md)
+ [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md)
+ [STL\$1RETURN](r_STL_RETURN.md)
+ [STL\$1SAVE](r_STL_SAVE.md)
+ [STL\$1SCAN](r_STL_SCAN.md)
+ [STL\$1SORT](r_STL_SORT.md)
+ [STL\$1STREAM\$1SEGS](r_STL_STREAM_SEGS.md)
+ [STL\$1UNIQUE](r_STL_UNIQUE.md)
+ [STL\$1WINDOW](r_STL_WINDOW.md)
+ [STV\$1EXEC\$1STATE](r_STV_EXEC_STATE.md)
+ [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md)
+ [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md)
+ [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md)
+ [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md)
+ [SVL\$1QUERY\$1REPORT](r_SVL_QUERY_REPORT.md)
+ [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md)
+ [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md)
## SYS\$1RESTORE\$1LOG
下列資料表中的部分或所有欄也會在 [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md)中定義。
+ [SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS](r_SVL_RESTORE_ALTER_TABLE_PROGRESS.md)
## SYS\$1RESTORE\$1STATE
下列資料表中的部分或所有欄也會在 [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md)中定義。
+ [STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE](r_STV_XRESTORE_ALTER_QUEUE_STATE.md)
## SYS\$1TRANSACTION\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md)中定義。
+ [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md)
+ [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md)
+ [STL\$1UNDONE](r_STL_UNDONE.md)
## SYS\$1QUERY\$1TEXT
下列資料表中的部分或所有欄也會在 [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md)中定義。
+ [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)
## SYS\$1CONNECTION\$1LOG
下列資料表中的部分或所有欄也會在 [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md)中定義。
+ [STL\$1CONNECTION\$1LOG](r_STL_CONNECTION_LOG.md)
## SYS\$1SESSION\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md)中定義。
+ [STL\$1SESSIONS](r_STL_SESSIONS.md)
+ [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md)
+ [STV\$1SESSIONS](r_STV_SESSIONS.md)
## SYS\$1LOAD\$1DETAIL
下列資料表中的部分或所有欄也會在 [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)中定義。
+ [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)
## SYS\$1LOAD\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md)中定義。
+ [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md)
## SYS\$1LOAD\$1ERROR\$1DETAIL
下列資料表中的部分或所有欄也會在 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)中定義。
+ [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md)
+ [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)
## SYS\$1UNLOAD\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md)中定義。
+ [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md)
## SYS\$1UNLOAD\$1DETAIL
下列資料表中的部分或所有欄也會在 [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md)中定義。
+ [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md)
## SYS\$1COPY\$1REPLACEMENTS
下列資料表中的部分或所有欄也會在 [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md)中定義。
+ [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md)
## SYS\$1DATASHARE\$1USAGE\$1CONSUMER
下列資料表中的部分或所有欄也會在 [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md)中定義。
+ [SVL\$1DATASHARE\$1USAGE\$1CONSUMER](r_SVL_DATASHARE_USAGE_CONSUMER.md)
## SYS\$1DATASHARE\$1USAGE\$1PRODUCER
下列資料表中的部分或所有欄也會在 [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md)中定義。
+ [SVL\$1DATASHARE\$1USAGE\$1PRODUCER](r_SVL_DATASHARE_USAGE_PRODUCER.md)
## SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
下列資料表中的部分或所有欄也會在 [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md)中定義。
+ [SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SVL_DATASHARE_CROSS_REGION_USAGE.md)
## SYS\$1DATASHARE\$1CHANGE\$1LOG
下列資料表中的部分或所有欄也會在 [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md)中定義。
+ [SVL\$1DATASHARE\$1CHANGE\$1LOG](r_SVL_DATASHARE_CHANGE_LOG.md)
## SYS\$1EXTERNAL\$1QUERY\$1DETAIL
下列資料表中的部分或所有欄也會在 [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)中定義。
+ [SVL\$1FEDERATED\$1QUERY](r_SVL_FEDERATED_QUERY.md)
+ [SVL\$1S3LIST](r_SVL_S3LIST.md)
+ [SVL\$1S3QUERY](r_SVL_S3QUERY.md)
+ [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md)
## SYS\$1EXTERNAL\$1QUERY\$1ERROR
下列資料表中的部分或所有欄也會在 [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md)中定義。
+ [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md)
## SYS\$1VACUUM\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)中定義。
+ [STL\$1VACUUM](r_STL_VACUUM.md)
+ [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md)
+ [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md)
+ [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md)
## SYS\$1ANALYZE\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md)中定義。
+ [STL\$1ANALYZE](r_STL_ANALYZE.md)
## SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md)中定義。
+ [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md)
## SYS\$1MV\$1REFRESH\$1HISTORY
下列資料表中的部分或所有欄也會在 [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md)中定義。
+ [SVL\$1MV\$1REFRESH\$1STATUS](r_SVL_MV_REFRESH_STATUS.md)
## SYS\$1MV\$1STATE
下列資料表中的部分或所有欄也會在 [SYS\$1MV\$1STATE](SYS_MV_STATE.md)中定義。
+ [STL\$1MV\$1STATE](r_STL_MV_STATE.md)
## SYS\$1PROCEDURE\$1CALL
下列資料表中的部分或所有欄也會在 [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md)中定義。
+ [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md)
## SYS\$1PROCEDURE\$1MESSAGES
下列資料表中的部分或所有欄也會在 [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md)中定義。
+ [SVL\$1STORED\$1PROC\$1MESSAGES](r_SVL_STORED_PROC_MESSAGES.md)
## SYS\$1UDF\$1LOG
下列資料表中的部分或所有欄也會在 [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md)中定義。
+ [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md)
## SYS\$1USERLOG
下列資料表中的部分或所有欄也會在 [SYS\$1USERLOG](SYS_USERLOG.md)中定義。
+ [STL\$1USERLOG](r_STL_USERLOG.md)
## SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
下列資料表中的部分或所有欄也會在 [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md)中定義。
+ [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md)
## SYS\$1SPATIAL\$1SIMPLIFY
下列資料表中的部分或所有欄也會在 [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md)中定義。
+ [SVL\$1SPATIAL\$1SIMPLIFY](r_SVL_SPATIAL_SIMPLIFY.md)
# 系統監控 (僅限已佈建)
您可以在已佈建的叢集上查詢下列系統資料表和檢視。STL 和 STV 資料表和檢視包含在數個系統資料表中找到的資料子集。這些項目可讓您快速輕鬆存取在那些資料表中找到的常見查詢資料。
SVCS 檢視可提供主要叢集與並行擴展叢集查詢的詳細資訊。SVL 檢視僅針對在主要叢集上執行的查詢提供資訊，但 SVL\$1STATEMENTTEXT 除外。SVL\$1STATEMENTTEXT 可以包含在並行擴縮叢集以及主要叢集上執行的查詢資訊。
**Topics**
+ [
# 用於記錄日誌的 STL 檢視
](c_intro_STL_tables.md)
+ [
# 快照資料的 STV 資料表
](c_intro_STV_tables.md)
+ [
# 主要和並行擴展叢集的 SVCS 檢視
](svcs_views.md)
+ [
# 主要叢集的 SVL 檢視
](svl_views.md)
# 用於記錄日誌的 STL 檢視
STL 系統檢視是從 Amazon Redshift 日誌檔產生，以提供系統歷史記錄。
這些檔案位於資料倉儲叢集中的每一個節點上。STL 檢視會從日誌中取得資訊，並將它們格式化為可供系統管理員使用的檢視。
**日誌保留** - STL 系統檢視會保留 7 天的日誌歷史記錄。所有叢集大小和節點類型都保證日誌保留，並且不受叢集工作負載變化的影響。日誌保留也不受叢集狀態的影響，例如叢集暫停時。只有在叢集是新的情況下，您才會有少於 7 天的日誌歷史記錄。您不需要採取任何動作來保留日誌，但必須定期將日誌資料複製到其他資料表，或將其卸載至 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_tw/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_tw/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)。
+ **巢狀迴圈**
巢狀迴路通常是 Cartesian 產品。評估您的查詢，以確保所有參與資料表均已有效聯結。
+ **選擇性相當高的篩選條件**
傳回的資料列與已掃描資料列的比率低於 0.05。已掃描列是 `rows_pre_user_filter` 的值，而傳回的列則是 [STL\$1SCAN](r_STL_SCAN.md) 系統檢視中的列值。表示查詢正在掃描例外狀況大量的資料列來決定結果集。這可能是由於找不到排序索引鍵或其不正確所致。如需詳細資訊，請參閱[排序索引鍵](t_Sorting_data.md)。
+ **過多的幽靈資料列**
掃描已略過相當多標示為已刪除但未清空的資料列，或已插入但未遞交的資料列。如需詳細資訊，請參閱[清空資料表](t_Reclaiming_storage_space202.md)。
+ **大型分佈**
已重新配送超過 1,000,000 個資料列，進行雜湊聯結或彙整。如需詳細資訊，請參閱[分配資料以實現查詢最佳化](t_Distributing_data.md)。
+ **大型廣播**
已播送超過 1,000,000 個資料列，進行雜湊聯結。如需詳細資訊，請參閱[分配資料以實現查詢最佳化](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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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 支援工程師可能會要求您在疑難排解程序中提供此資訊。
所有使用者都可看見 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_tw/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_tw/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
傳回 Amazon Redshift 在使用 COPY 命令載入資料時讀取的檔案。
查詢此檢視有助於對資料載入錯誤進行故障診斷。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_tw/redshift/latest/dg/r_STL_FILE_SCAN.html)
## 範例查詢
下列查詢擷取 Amazon Redshift 需要超過 1,000,000 微秒來讀取之任何檔案的名稱和載入時間。
```
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_tw/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_tw/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_tw/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_tw/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_tw/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\$1ERROR。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](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_tw/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 無法剖析該欄位，即會發生剖析錯誤。例如，如果資料表資料欄預期 integer 資料類型，但資料檔案在該欄位中包含一串字母，則其會導致剖析錯誤。
在您查詢 [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_tw/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_tw/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_tw/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_tw/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_tw/redshift/latest/dg/r_STL_NESTLOOP.html)
## 範例查詢
由於下列查詢會忽略聯結 CATEGORY 資料表，因此它會產生局部 Cartesian 產品，而我們不建議這樣做。在這裡顯示它，是為了說明巢狀迴路。
```
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_tw/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_tw/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_tw/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_tw/redshift/latest/dg/r_STL_QUERY.html)
## 範例查詢
下列查詢會列出五個最新查詢。
```
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) 系統檢視。
查詢指標每間隔一秒鐘取樣一次。因此，相同查詢的不同執行可能會傳回稍微不同的時間。另外，可能不會記錄執行時間不到一秒的查詢區段。
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_tw/redshift/latest/dg/r_STL_QUERY_METRICS.html)
## 範例查詢
若要找出具有高 CPU 時間 (超過 1,000 秒) 的查詢，請執行下列查詢。
```
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_tw/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。請先以新的一行取代任意 (`\n`) 特殊字元，再執行重建的 SQL。下列 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
顯示一個日誌，其記錄搭配 ACCEPTINVCHARS 選項的 [COPY](r_COPY.md) 命令何時取代無效的 UTF-8 字元。在至少需要一個取代項目的每個節點上，對於其前 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_tw/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_tw/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_tw/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_tw/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_tw/redshift/latest/dg/r_STL_S3CLIENT_ERROR.html)
## 使用須知
如果看到多個錯誤具有「連線逾時」，則可能發生聯網問題。如果您使用的是增強型 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_tw/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_tw/redshift/latest/dg/r_STL_SCAN.html)
## 掃描類型
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/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` 之間的差異是查詢所篩選的資料列數目。若有許多資料列已遭使用者篩選條件捨棄，請檢閱您選擇的排序資料欄，或若這是由於大型未排序區域所致，請執行清空。
## 範例查詢
下列範例顯示 `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
超過結構描述配額時，記錄出現次數、時間戳記、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_tw/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;
```
此查詢會傳回所指定結構描述的下列範例輸出：
```
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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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
+ 取消
+ 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_tw/redshift/latest/dg/r_STL_UTILITYTEXT.html)
## 範例查詢
下列查詢會傳回已在 2012 年 1 月 26 日執行之「公用程式」命令的文字。在此案例中，系統已執行部分 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。請先以新的一行取代任意 (`\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_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](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_tw/redshift/latest/dg/r_STL_VACUUM.html)
## 範例查詢
下列查詢報告資料表 108313 的清空統計資訊。在一系列插入和刪除之後已清空此資料表。
```
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 開始時，資料表包含 1,950 列，儲存在 28 個 1 MB 區塊中。Amazon Redshift 估計，透過清空操作可以回收 984 個磁碟空間，即 17 個磁碟空間區塊。
在「已完成」狀態的列中，ROWS 欄顯示的值為 966，而 BLOCKS 欄的值從 28 下降為 11。清空回收了估計的磁碟空間量，清空操作完成後沒有剩餘可回收的列或空間。
在排序階段 (交易 15126) 中，清空能夠略過資料表，因為已依排序索引鍵順序插入資料列。
下列範例會在大型 INSERT 操作之後顯示 SALES 資料表 (此範例中的資料表 110116) 上 SORT ONLY 清空的統計資訊：
```
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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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。其中包括擷取 SQL 命令查詢文字的 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)，以及將 STV\$1INFLIGHT 連接至 STL\$1QUERYTEXT 的 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)。您也可以搭配 [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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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) 系統資料表。
查詢指標每間隔一秒鐘取樣一次。因此，相同查詢的不同執行可能會傳回稍微不同的時間。另外，可能不會記錄執行時間不到一秒的查詢區段。
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_tw/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## 步驟類型
下表列出與資料庫使用者相關的步驟類型。此表未列出僅供內部使用的步驟類型。如果步驟類型為 -1，則該步驟層級不會回報該指標。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## 範例查詢
若要找出具有高 CPU 時間 (超過 1,000 秒) 的使用中查詢，請執行下列查詢。
```
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 監控檢視進行查詢。
## Troubleshooting with STV\$1RECENTS
STV\$1RECENTS 對於確定查詢或查詢集合目前是否正在執行或已完成特別有用。它也會顯示查詢執行的持續時間。這對於了解哪些查詢長時間執行很有幫助。
您可以將 STV\$1RECENTS 聯結至其他系統檢視，例如 [STV\$1INFLIGHT](r_STV_INFLIGHT.md)，以收集有關執行查詢的其他中繼資料。(範例查詢部分中有一個範例展示如何執行此操作。) 您也可以使用此檢視中的傳回記錄以及 Amazon Redshift 主控台中的監控功能，進行即時疑難排解。
補充 STV\$1RECENTS 的系統檢視包括 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) (會擷取 SQL 命令的查詢文字)，以及 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md) (會將 STV\$1INFLIGHT 連接到 STL\$1QUERYTEXT)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/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_tw/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_tw/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_tw/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_tw/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 刪除 2 個資料列，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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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)。
+ **巢狀迴圈**
巢狀迴路通常是 Cartesian 產品。評估您的查詢，以確保所有參與資料表均已有效聯結。
+ **選擇性相當高的篩選條件**
傳回的資料列與已掃描資料列的比率低於 0.05。已掃描資料列是 `rows_pre_user_filter `的值，而傳回的資料列則是 [STL\$1SCAN](r_STL_SCAN.md) 系統資料表中的資料列值。表示查詢正在掃描例外狀況大量的資料列來決定結果集。這可能是由於找不到排序索引鍵或其不正確所致。如需詳細資訊，請參閱[排序索引鍵](t_Sorting_data.md)。
+ **過多的幽靈資料列**
掃描已略過相當多標示為已刪除但未清空的資料列，或已插入但未遞交的資料列。如需詳細資訊，請參閱[清空資料表](t_Reclaiming_storage_space202.md)。
+ **大型分佈**
已重新配送超過 1,000,000 個資料列，進行雜湊聯結或彙整。如需詳細資訊，請參閱[分配資料以實現查詢最佳化](t_Distributing_data.md)。
+ **大型廣播**
已播送超過 1,000,000 個資料列，進行雜湊聯結。如需詳細資訊，請參閱[分配資料以實現查詢最佳化](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_tw/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_tw/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_tw/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_tw/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_tw/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 的任何查詢步驟 (請參閱 [SVL\$1QLOG](r_SVL_QLOG.md) 檢視來了解如何取得查詢的查詢 ID) 是否溢出至磁碟或查詢完全在記憶體內執行：
```
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，雜湊步驟在磁碟上執行。步驟可能在包含雜湊、彙總或排序步驟的磁碟上執行。若要只檢視磁碟型的查詢步驟，將 **and is\$1diskbased = 't'** 子句新增至以上範例的 SQL 陳述式。
# 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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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\$1STATMENT\$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_tw/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_tw/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 會從 [STL\$1QUERY](r_STL_QUERY.md) 資料表以可讀資訊子集的形式建立 SVL\$1QLOG 檢視。使用此資料表來找出最近執行之查詢的查詢 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_tw/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)
```
下列範例會傳回 SQL 指令碼名稱 (LABEL 欄位) 和已取消查詢的歷經時間 (**aborted=1**)：
```
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_tw/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_tw/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_tw/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_tw/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_tw/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 的任何查詢步驟 (請參閱 [SVL\$1QLOG](r_SVL_QLOG.md) 檢視來了解如何取得查詢的查詢 ID) 是否溢出至磁碟或查詢完全在記憶體內執行：
```
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，雜湊步驟在磁碟上執行。步驟可能在包含雜湊、彙總或排序步驟的磁碟上執行。若要只檢視磁碟型的查詢步驟，將 **and is\$1diskbased = 't'** 子句新增至以上範例的 SQL 陳述式。
# 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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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_tw/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
您可以使用 COPY 命令查詢系統檢視 SVL\$1SPATIAL\$1SIMPLIFY 以取得簡化空間幾何物件的資訊。當您在 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_tw/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_tw/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_tw/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。請先以新的一行取代任意 (`\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 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_tw/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_tw/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，只有 NOTICE、WARNING 和 EXCEPTION 層級訊息會記錄在 SVL\$1STORED\$1PROC\$1MESSAGES 中。
```
-- 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_tw/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_tw/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_tw/redshift/latest/dg/r_SVL_USER_INFO.html)
## 範例查詢
下列命令會從 SVL\$1USER\$1INFO 擷取使用者資訊。
```
SELECT * FROM SVL_USER_INFO;
```
# SVL\$1VACUUM\$1PERCENTAGE
SVL\$1VACUUM\$1PERCENTAGE 檢視報告在執行清空後為資料表配置的資料區塊百分比。此百分比數顯示磁碟空間的回收量。如需清空公用程式的相關資訊，請參閱 [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_tw/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)
```
在此清空操作後，資料表包含原始區塊的 60%。
# 系統目錄資料表
**Topics**
+ [
# PG\$1ATTRIBUTE\$1INFO
](r_PG_ATTRIBUTE_INFO.md)
+ [
# PG\$1CLASS\$1INFO
](r_PG_CLASS_INFO.md)
+ [
# PG\$1DATABASE\$1INFO
](r_PG_DATABASE_INFO.md)
+ [
# PG\$1DEFAULT\$1ACL
](r_PG_DEFAULT_ACL.md)
+ [
# PG\$1EXTERNAL\$1SCHEMA
](r_PG_EXTERNAL_SCHEMA.md)
+ [
# PG\$1LIBRARY
](r_PG_LIBRARY.md)
+ [
# PG\$1PROC\$1INFO
](r_PG_PROC_INFO.md)
+ [
# PG\$1STATISTIC\$1INDICATOR
](r_PG_STATISTIC_INDICATOR.md)
+ [
# PG\$1TABLE\$1DEF
](r_PG_TABLE_DEF.md)
+ [
# PG\$1USER\$1INFO
](pg_user_info.md)
+ [
# 查詢目錄資料表
](c_join_PG.md)
系統目錄儲存結構描述中繼資料，例如資料表和資料欄的相關資訊。系統目錄資料表有 PG 字首。
Amazon Redshift 使用者可存取標準 PostgreSQL 目錄資料表。如需 PostgreSQL 系統目錄的相關資訊，請參閱 [PostgreSQL system tables](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW)
# PG\$1ATTRIBUTE\$1INFO
PG\$1ATTRIBUTE\$1INFO 是以 PostgreSQL 目錄資料表 PG\$1ATTRIBUTE 和內部目錄資料表 PG\$1ATTRIBUTE\$1ACL 為基礎建立的 Amazon Redshift 系統檢視。PG\$1ATTRIBUTE\$1INFO 包含資料表或檢視的資料欄詳細資訊，其中包括資料欄存取控制清單 (如果有的話)。
## 資料表欄
除了 PG\$1ATTRIBUTE 中的資料欄，PG\$1ATTRIBUTE\$1INFO 還會顯示下列幾個資料欄。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html)
# PG\$1CLASS\$1INFO
PG\$1CLASS\$1INFO 是一個 Amazon Redshift 系統檢視，以 PostgreSQL 類別資料表 PG\$1CLASS 和 PG\$1CLASS\$1EXTENDED 為建置基礎。PG\$1CLASS\$1INFO 包含關於資料表建立時間和目前分佈樣式的詳細資訊。如需詳細資訊，請參閱[分配資料以實現查詢最佳化](t_Distributing_data.md)。
所有使用者都可看見 PG\$1CLASS\$1INFO。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
除了 PG\$1CLASS 中的資料欄，PG\$1CLASS\$1INFO 會顯示下列資料欄。PG\$1CLASS 中的 `oid` 欄在 PG\$1CLAS\$1INFO 資料表中稱為 `reloid`。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_CLASS_INFO.html)
PG\$1CLASS\$1INFO 中的 RELEFFECTIVEDISTSTYLE 欄指出資料表的目前分佈樣式。如果資料表使用自動分佈，則 RELEFFECTIVEDISTSTYLE 為 10、11 或 12，這指出有效分佈樣式為 AUTO (ALL)、AUTO (EVEN) 或 AUTO (KEY)。如果資料表使用自動分布，則分佈樣式一開始可能顯示 AUTO (ALL)，然後當資料表成長時變更為 AUTO (EVEN)，如果發現某欄可用作分佈索引鍵，則變更為 AUTO (KEY)。
下表提供 RELEFFECTIVEDISTSTYLE 欄中每個值的分佈樣式：
| RELEFFECTIVEDISTSTYLE | 目前分佈樣式 |
| --- | --- |
| 0 | EVEN |
| 1 | KEY |
| 8 | ALL |
| 10 | AUTO (ALL) |
| 11 | AUTO (EVEN) |
| 12 | AUTO (KEY) |
## 範例
下列查詢會傳回目錄中資料表的目前分佈樣式。
```
select reloid as tableid,trim(nspname) as schemaname,trim(relname) as tablename,reldiststyle,releffectivediststyle,
CASE WHEN "reldiststyle" = 0 THEN 'EVEN'::text
WHEN "reldiststyle" = 1 THEN 'KEY'::text
WHEN "reldiststyle" = 8 THEN 'ALL'::text
WHEN "releffectivediststyle" = 10 THEN 'AUTO(ALL)'::text
WHEN "releffectivediststyle" = 11 THEN 'AUTO(EVEN)'::text
WHEN "releffectivediststyle" = 12 THEN 'AUTO(KEY)'::text ELSE '<>'::text END as diststyle,relcreationtime
from pg_class_info a left join pg_namespace b on a.relnamespace=b.oid;
```
```
tableid | schemaname | tablename | reldiststyle | releffectivediststyle | diststyle | relcreationtime
---------+------------+-----------+--------------+-----------------------+------------+----------------------------
3638033 | public | customer | 0 | 0 | EVEN | 2019-06-13 15:02:50.666718
3638037 | public | sales | 1 | 1 | KEY | 2019-06-13 15:03:29.595007
3638035 | public | lineitem | 8 | 8 | ALL | 2019-06-13 15:03:01.378538
3638039 | public | product | 9 | 10 | AUTO(ALL) | 2019-06-13 15:03:42.691611
3638041 | public | shipping | 9 | 11 | AUTO(EVEN) | 2019-06-13 15:03:53.69192
3638043 | public | support | 9 | 12 | AUTO(KEY) | 2019-06-13 15:03:59.120695
(6 rows)
```
# PG\$1DATABASE\$1INFO
PG\$1DATABASE\$1INFO 是以 PostgreSQL 目錄資料表 PG\$1DATABASE 為延伸基礎的 Amazon Redshift 系統檢視。
所有使用者都可看見 PG\$1DATABASE\$1INFO。
## 資料表欄
除了 PG\$1DATABASE 中的資料欄外，PG\$1DATABASE\$1INFO 還包含下列資料欄。PG\$1DATABASE 中的 `oid` 欄在 PG\$1DATABASE\$1INFO 資料表中稱為 `datid`。如需詳細資訊，請參閱 [PostgreSQL 文件](https://www.postgresql.org/docs/8.0/catalog-pg-database.html)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_DATABASE_INFO.html)
# PG\$1DEFAULT\$1ACL
儲存預設存取權限的相關資訊。如需預設存取權限的相關資訊，請參閱 [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md)。
所有使用者都可看見 PG\$1DEFAULT\$1ACL。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_DEFAULT_ACL.html)
## 範例
下列查詢會傳回為資料庫定義之所有預設權限。
```
select pg_get_userbyid(d.defacluser) as user,
n.nspname as schema,
case d.defaclobjtype when 'r' then 'tables' when 'f' then 'functions' end
as object_type,
array_to_string(d.defaclacl, ' + ') as default_privileges
from pg_catalog.pg_default_acl d
left join pg_catalog.pg_namespace n on n.oid = d.defaclnamespace;
user | schema | object_type | default_privileges
-------+--------+-------------+-------------------------------------------------------
admin | tickit | tables | user1=r/admin + "group group1=a/admin" + user2=w/admin
```
前述範例中的結果顯示針對在 `admin` 結構描述中的使用者 `tickit` 所建立的所有新資料表，`admin` 將 SELECT 權限授予給 `user1`、INSERT 權限授予給 `group1` 而 UPDATE 權限授予給 `user2`。
# PG\$1EXTERNAL\$1SCHEMA
儲存外部結構描述的相關資訊。
所有使用者都可看見 PG\$1EXTERNAL\$1SCHEMA。超級使用者可以看見所有資料列；一般使用者只能看見它們有權存取的中繼資料。如需詳細資訊，請參閱[CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_EXTERNAL_SCHEMA.html)
## 範例
下列範例顯示外部結構描述的詳細資訊。
```
select esoid, nspname as schemaname, nspowner, esdbname as external_db, esoptions
from pg_namespace a,pg_external_schema b where a.oid=b.esoid;
esoid | schemaname | nspowner | external_db | esoptions
-------+-----------------+----------+-------------+-------------------------------------------------------------
100134 | spectrum_schema | 100 | spectrum_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
100135 | spectrum | 100 | spectrumdb | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
100149 | external | 100 | external_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
```
# PG\$1LIBRARY
儲存使用者定義之資料庫的相關資訊。
所有使用者都可看見 PG\$1LIBRARY。超級使用者可以看見所有資料列；一般使用者只能看見自己的資料。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_LIBRARY.html)
## 範例
以下範例會傳回使用者安裝資料庫的資訊。
```
select * from pg_library;
name | language_oid | file_store_id | owner
-----------+--------------+---------------+------
f_urlparse | 108254 | 2000 | 100
```
# PG\$1PROC\$1INFO
PG\$1PROC\$1INFO 是以 PostgreSQL 目錄資料表 PG\$1PROC 和內部目錄資料表 PG\$1PROC\$1EXTENDED 為基礎建立的 Amazon Redshift 系統檢視。PG\$1PROC\$1INFO 包含儲存程序和函數的詳細資訊，包括輸出引數 (若有) 的相關資訊。
## 資料表欄
除了 PG\$1PROG 中的欄，PG\$1PROC\$1INFO 還會顯示下列幾欄。PG\$1PROC 中的 `oid` 欄在 PG\$1PROC\$1INFO 資料表中稱為 `prooid`。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_PROC_INFO.html)
PG\$1PROC\$1INFO 中的欄位 proargnames 包含所有類型的引數 (包括 OUT 和 INOUT) 的名稱 (若有)。
# PG\$1STATISTIC\$1INDICATOR
儲存自前次 ANALYZE 以來插入或刪除的列數之相關資訊。PG\$1STATISTIC\$1INDICATOR 資料表會在下列 DML 操作後頻繁的更新，因此統計資訊是近似值。
只有超級使用者可以看到 PG\$1STATISTIC\$1INDICATOR。如需詳細資訊，請參閱[系統資料表和檢視中資料的可見性](cm_chap_system-tables.md#c_visibility-of-data)。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_STATISTIC_INDICATOR.html)
## 範例
以下範例會傳回自前次 ANALYZE 以來資料表變更的資訊。
```
select * from pg_statistic_indicator;
stairelid | stairows | staiins | staidels
----------+----------+---------+---------
108271 | 11 | 0 | 0
108275 | 365 | 0 | 0
108278 | 8798 | 0 | 0
108280 | 91865 | 0 | 100632
108267 | 89981 | 49990 | 9999
108269 | 808 | 606 | 374
108282 | 152220 | 76110 | 248566
```
# PG\$1TABLE\$1DEF
儲存資料表欄位的相關資訊。
PG\$1TABLE\$1DEF 僅傳回使用者可見之資料表的相關資訊。如果 PG\$1TABLE\$1DEF 未傳回預期的結果，確認 [search\$1path](r_search_path.md) 參數是否正確設定為包含相關的結構描述。
您可以使用 [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md) 來檢視資料表的更全面性資訊，包括資料配送偏度、索引鍵配送偏度、資料表大小、統計等方面的問題。
## 資料表欄
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/r_PG_TABLE_DEF.html)
## 範例
下列範例顯示 LINEORDER\$1COMPOUND 資料表的複合排序索引鍵欄位。
```
select "column", type, encoding, distkey, sortkey, "notnull"
from pg_table_def
where tablename = 'lineorder_compound'
and sortkey <> 0;
column | type | encoding | distkey | sortkey | notnull
-------------+---------+----------+---------+---------+--------
lo_orderkey | integer | delta32k | false | 1 | true
lo_custkey | integer | none | false | 2 | true
lo_partkey | integer | none | true | 3 | true
lo_suppkey | integer | delta32k | false | 4 | true
lo_orderdate | integer | delta | false | 5 | true
(5 rows)
```
下列範例顯示 LINEORDER\$1INTERLEAVED 資料表的交錯排序索引鍵欄位。
```
select "column", type, encoding, distkey, sortkey, "notnull"
from pg_table_def
where tablename = 'lineorder_interleaved'
and sortkey <> 0;
column | type | encoding | distkey | sortkey | notnull
-------------+---------+----------+---------+---------+--------
lo_orderkey | integer | delta32k | false | -1 | true
lo_custkey | integer | none | false | 2 | true
lo_partkey | integer | none | true | -3 | true
lo_suppkey | integer | delta32k | false | 4 | true
lo_orderdate | integer | delta | false | -5 | true
(5 rows)
```
PG\$1TABLE\$1DEF 將僅傳回在搜尋路徑中包含之結構描述中資料表的相關資訊。如需詳細資訊，請參閱[search\$1path](r_search_path.md)。
例如，假設您建立新結構描述和新資料表，以及查詢 PG\$1TABLE\$1DEF。
```
create schema demo;
create table demo.demotable (one int);
select * from pg_table_def where tablename = 'demotable';
schemaname|tablename|column| type | encoding | distkey | sortkey | notnull
----------+---------+------+------+----------+---------+---------+--------
```
查詢未傳回新資料表的任何列。檢查 `search_path` 的設定。
```
show search_path;
search_path
---------------
$user, public
(1 row)
```
將 `demo` 結構描述新增至搜尋路徑中並再次執行查詢。
```
set search_path to '$user', 'public', 'demo';
select * from pg_table_def where tablename = 'demotable';
schemaname| tablename |column| type | encoding |distkey|sortkey| notnull
----------+-----------+------+---------+----------+-------+-------+--------
demo | demotable | one | integer | none | f | 0 | f
(1 row)
```
# PG\$1USER\$1INFO
PG\$1USER\$1INFO 是 Amazon Redshift 系統檢視，用於顯示使用者訊息，例如使用者 ID 和密碼過期時間。
只有超級使用者可以看到 PG\$1USER\$1INFO。
## 資料表欄
PG\$1USER\$1INFO 包含下列欄。如需詳細資訊，請參閱 [PostgreSQL 文件](https://www.postgresql.org/docs/8.0/view-pg-user.html)。
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/zh_tw/redshift/latest/dg/pg_user_info.html)
# 查詢目錄資料表
**Topics**
+ [
# 目錄查詢範例
](c_join_PG_examples.md)
通常，您可以將目錄資料表和檢視 (其名稱開頭為 **PG\$1** 的關係) 聯結至 Amazon Redshift 資料表和檢視。
目錄資料表使用 Amazon Redshift 不支援的各種資料類型。下列資料類型在將查詢對 Amazon Redshift 資料表聯結目錄資料表時受到支援：
+ bool
+ "char"
+ float4
+ int2
+ int4
+ int8
+ name
+ oid
+ text
+ varchar
如果您寫入加入查詢，其明確或隱含地參考擁有不受支援之資料類型的欄位，則查詢會傳回錯誤。在某些目錄資料表中使用的 SQL 函數也不受支援，除非是 PG\$1SETTINGS 和 PG\$1LOCKS 資料表所用的那些函數。
例如，PG\$1STATS 資料表不得與 Amazon Redshift 資料表一同受到查詢，因為此功能不受支援。
下列目錄資料表和檢視提供的資訊很有用，您可以將其與 Amazon Redshift 資料表中的資訊結合在一起。因為資料類型和函數限制，部分資料表僅允許部分存取權。當您查詢可部分存取的資料表時，請小心地選取或參考其欄位。
以下資料表是可完整存取的，且未包含不受支援的函數類型：
+ [pg\$1attribute](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html)
+ [pg\$1cast](https://www.postgresql.org/docs/8.0/static/catalog-pg-cast.html)
+ [pg\$1depend](https://www.postgresql.org/docs/8.0/static/catalog-pg-depend.html)
+ [pg\$1description](https://www.postgresql.org/docs/8.0/static/catalog-pg-description.html)
+ [pg\$1locks](https://www.postgresql.org/docs/8.0/static/view-pg-locks.html)
+ [pg\$1opclass](https://www.postgresql.org/docs/8.0/static/catalog-pg-opclass.html)
以下資料表是可部分存取的，且包含一些不受支援類型、函數和遭截斷的文字欄位。文字欄位中的值遭截斷為 varchar(256) 值。
+ [pg\$1class](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html)
+ [pg\$1constraint](https://www.postgresql.org/docs/8.0/static/catalog-pg-constraint.html)
+ [pg\$1database](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html)
+ [pg\$1group](https://www.postgresql.org/docs/8.0/static/catalog-pg-group.html)
+ [pg\$1language](https://www.postgresql.org/docs/8.0/static/catalog-pg-language.html)
+ [pg\$1namespace](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html)
+ [pg\$1operator](https://www.postgresql.org/docs/8.0/static/catalog-pg-operator.html)
+ [pg\$1proc](https://www.postgresql.org/docs/8.0/static/catalog-pg-proc.html)
+ [pg\$1settings](https://www.postgresql.org/docs/8.0/static/view-pg-settings.html)
+ [pg\$1statistic](https://www.postgresql.org/docs/8.0/static/catalog-pg-statistic.html)
+ [pg\$1tables](https://www.postgresql.org/docs/8.0/static/view-pg-tables.html)
+ [pg\$1type](https://www.postgresql.org/docs/8.0/static/catalog-pg-type.html)
+ [pg\$1user](https://www.postgresql.org/docs/8.0/static/view-pg-user.html)
+ [pg\$1views](https://www.postgresql.org/docs/8.0/static/view-pg-views.html)
未在此處列出的目錄資料表為不可存取或可能未供 Amazon Redshift 管理員使用。然而，如果您的查詢不包含對 Amazon Redshift 資料表的加入時，您可以開放地查詢任何目錄資料表或檢視。
您可以使用 Postgres 目錄資料表中的 OID 欄位做為加入欄位。例如，加入條件 `pg_database.oid = stv_tbl_perm.db_id` 符合每個 PG\$1DATABASE 列的內部資料庫物件 ID，內含 STV\$1TBL\$1PERM 資料表中可見的 DB\$1ID 欄位。OID 欄位是內部主要索引鍵，當您從資料表進行選取時無法看見此欄位。目錄檢視沒有 OID 欄位。
某些 Amazon Redshift 函數必須只能在運算節點上執行。如果查詢參考的是使用者建立的資料表，SQL 會在運算節點上執行。
查詢如果只參考目錄資料表 (具有 PG 字首的資料表，例如 PG\$1TABLE\$1DEF)，或是未參考任何資料表，就只會在領導節點上執行。
如果使用運算節點函數的查詢未參考使用者定義的資料表或 Amazon Redshift 系統資料表傳回下列錯誤。
```
[Amazon](500310) Invalid operation: One or more of the used functions must be applied on at least one user created table.
```
# 目錄查詢範例
下列查詢顯示幾個方法，您可以用這些方法來查詢目錄資料表來取得 Amazon Redshift 資料庫的相關有用資訊。
## 檢視資料表 ID、資料庫、結構描述和資料表名稱
下列檢視定義加入 STV\$1TBL\$1PERM 系統資料表和 PG\$1CLASS、PG\$1NAMESPACE 和 PG\$1DATABASE 系統目錄資料表，以傳回資料表 ID、資料庫名稱、結構描述名稱和資料表名稱。
```
create view tables_vw as
select distinct(stv_tbl_perm.id) table_id
,trim(pg_database.datname) db_name
,trim(pg_namespace.nspname) schema_name
,trim(pg_class.relname) table_name
from stv_tbl_perm
join pg_class on pg_class.oid = stv_tbl_perm.id
join pg_namespace on pg_namespace.oid = pg_class.relnamespace
join pg_database on pg_database.oid = stv_tbl_perm.db_id;
```
下列範例會回傳資料表 ID 117855 的資訊。
```
select * from tables_vw where table_id = 117855;
```
```
table_id | db_name | schema_name | table_name
---------+-----------+-------------+-----------
117855 | dev | public | customer
```
## 根據 Amazon Redshift 資料表列出欄數
下列查詢會聯結一些目錄資料表，以瞭解每個 Amazon Redshift 資料表包含多少個欄。Amazon Redshift 資料表名稱同時儲存在 PG\$1TABLES 和 STV\$1TBL\$1PERM 中；請盡可能使用 PG\$1TABLES 傳回 Amazon Redshift 資料表名稱。
此查詢不包含任何 Amazon Redshift 資料表。
```
select nspname, relname, max(attnum) as num_cols
from pg_attribute a, pg_namespace n, pg_class c
where n.oid = c.relnamespace and a.attrelid = c.oid
and c.relname not like '%pkey'
and n.nspname not like 'pg%'
and n.nspname not like 'information%'
group by 1, 2
order by 1, 2;
nspname | relname | num_cols
--------+----------+----------
public | category | 4
public | date | 8
public | event | 6
public | listing | 8
public | sales | 10
public | users | 18
public | venue | 5
(7 rows)
```
## 列出資料庫中的結構描述和資料表
下列查詢會將 STV\$1TBL\$1PERM 加入至部分 PG 資料表以在 TICKIT 資料庫和其結構描述名稱 (NSPNAME 欄位) 中傳回資料表清單。查詢也會傳回每個資料表中的列總數。(當系統中多個結構描述的資料表名稱相同時，此查詢相當實用。)
```
select datname, nspname, relname, sum(rows) as rows
from pg_class, pg_namespace, pg_database, stv_tbl_perm
where pg_namespace.oid = relnamespace
and pg_class.oid = stv_tbl_perm.id
and pg_database.oid = stv_tbl_perm.db_id
and datname ='tickit'
group by datname, nspname, relname
order by datname, nspname, relname;
datname | nspname | relname | rows
--------+---------+----------+--------
tickit | public | category | 11
tickit | public | date | 365
tickit | public | event | 8798
tickit | public | listing | 192497
tickit | public | sales | 172456
tickit | public | users | 49990
tickit | public | venue | 202
(7 rows)
```
## 列出資料表 ID、資料類型、欄位名稱和資料表名稱
下列查詢列出每個使用者資料表和其欄位的部分相關資訊：資料表 ID、資料表名稱、其欄位名稱和每個欄位的資料類型：
```
select distinct attrelid, rtrim(name), attname, typname
from pg_attribute a, pg_type t, stv_tbl_perm p
where t.oid=a.atttypid and a.attrelid=p.id
and a.attrelid between 100100 and 110000
and typname not in('oid','xid','tid','cid')
order by a.attrelid asc, typname, attname;
attrelid | rtrim | attname | typname
---------+----------+----------------+-----------
100133 | users | likebroadway | bool
100133 | users | likeclassical | bool
100133 | users | likeconcerts | bool
...
100137 | venue | venuestate | bpchar
100137 | venue | venueid | int2
100137 | venue | venueseats | int4
100137 | venue | venuecity | varchar
...
```
## 為資料表中的每個欄位計數資料區塊數
下列查詢會將 STV\$1BLOCKLIST 資料表加入至 PG\$1CLASS，以傳回 SALES 資料表中欄位的儲存資訊。
```
select col, count(*)
from stv_blocklist s, pg_class p
where s.tbl=p.oid and relname='sales'
group by col
order by col;
col | count
----+-------
0 | 4
1 | 4
2 | 4
3 | 4
4 | 4
5 | 4
6 | 4
7 | 4
8 | 4
9 | 8
10 | 4
12 | 4
13 | 8
(13 rows)
```