Amazon Redshift는 패치 198부터 새 Python UDF 생성을 더 이상 지원하지 않습니다. 기존 Python UDF는 2026년 6월 30일까지 계속 작동합니다. 자세한 내용은 [블로그 게시물](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/)을 참조하세요.
# 시스템 테이블 및 뷰 참조
Amazon Redshift는 시스템 작동 방식에 대한 정보가 저장되어 있는 시스템 테이블 및 뷰가 많습니다. 이러한 시스템 테이블 및 뷰 역시 다른 데이터베이스 테이블에 대한 쿼리와 동일한 방법으로 쿼리를 실행할 수 있습니다. 이번 섹션에서는 몇 가지 시스템 테이블 쿼리 샘플을 살펴보면서 다음과 같은 주제를 가지고 설명하겠습니다.
+ 다양한 유형의 시스템 테이블 및 뷰 생성
+ 이러한 테이블에서 얻을 수 있는 정보 유형
+ Amazon Redshift 시스템 테이블을 카탈로그 테이블에 조인하는 방법
+ 점점 증가하는 시스템 테이블 로그 파일의 관리 방법
일부 시스템 테이블은 진단 목적으로 AWS 직원만 사용할 수 있습니다. 다음 섹션에서는 시스템 관리자 또는 데이터베이스 사용자가 유용한 정보를 얻기 위해 쿼리를 실행할 수 있는 시스템 테이블에 대해서 얘기하겠습니다.
**참고**
시스템 테이블은 자동 또는 수동 클러스터 백업(스냅샷)에 포함되지 않습니다. STL 시스템 뷰는 7일간의 로그 기록을 보존합니다. 따라서 로그 보존에는 별도의 고객 조치가 필요하지 않습니다. 따라서 로그 데이터를 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 문의 전체 텍스트가 포함되며, 여기에는 사용자가 생성한 민감한 데이터가 포함될 수 있습니다.
수퍼유저는 모든 테이블의 모든 행을 볼 수 있습니다. 일반 사용자에게 수퍼유저 가시성 테이블에 대한 액세스를 제공하려면 해당 테이블에 대한 [GRANT](r_GRANT.md) SELECT 권한을 일반 사용자에게 부여합니다.
### 시스템 생성 쿼리 필터링
일반적으로 쿼리 관련 시스템 테이블 및 뷰(SVL\$1QUERY\$1SUMMARY, SVL\$1QLOG 등)에는 Amazon Redshift에서 데이터베이스 상태를 모니터링하는 데 사용하는 자동 생성 문이 다수 포함되어 있습니다. 이러한 시스템 생성 쿼리도 수퍼유저에게 노출되지만 사용할 일은 거의 없습니다. 따라서 `userid` 열을 사용하는 시스템 테이블이나 시스템 뷰에서 선택할 때 이러한 쿼리를 필터링하려면 WHERE 절에 `userid > 1` 조건을 추가하면 됩니다. 예제:
```
select * from svl_query_summary where userid > 1
```
## 프로비저닝 전용 쿼리를 SYS 모니터링 뷰 쿼리로 마이그레이션
### 프로비저닝된 클러스터에서 Amazon Redshift Serverless로 마이그레이션
프로비저닝된 클러스터를 Amazon Redshift Serverless로 마이그레이션하는 경우 프로비저닝된 클러스터의 데이터만 저장하는 다음과 같은 시스템 뷰를 사용하는 쿼리가 있을 수 있습니다.
+ 모든 STL 뷰
+ 모든 STV 뷰
+ 모든 SVCS 뷰
+ 모든 SVL 뷰
+ 일부 SVV 뷰
+ Amazon Redshift Serverless에서 지원되지 않는 SVV 뷰의 전체 목록은 **Amazon Redshift 관리 안내서의 [Amazon Redshift Serverless로 쿼리 및 워크로드 모니터링](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-monitoring.html) 하단에 있는 목록을 참조하세요.
쿼리를 계속 사용하려면 SYS 모니터링 뷰에서 정의되었으며 프로비저닝 전용 뷰의 열에 해당하는 열을 사용하도록 쿼리를 다시 구성하세요. 프로비저닝 전용 뷰와 SYS 모니터링 뷰 간의 매핑 관계는 [SYS 모니터링 뷰로 마이그레이션하기 위한 시스템 뷰 매핑](sys_view_migration.md) 섹션을 참조하세요.
### 프로비저닝된 클러스터에 머물면서 쿼리 업데이트
Amazon Redshift Serverless로 마이그레이션하지 않는 경우에도 기존 쿼리를 업데이트하고 싶을 수 있습니다. SYS 모니터링 뷰는 사용 편의성과 복잡성 감소를 위해 설계되어 효과적인 모니터링 및 문제 해결을 위한 완전한 지표를 제공합니다. 여러 개의 프로비저닝 전용 뷰의 정보를 통합하는 [SYS\$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)과 같은 SYS 모니터링 뷰에는 사용자 쿼리에 대한 식별자가 들어 있는 query\$1id 열이 포함됩니다. 마찬가지로 [STL\$1QUERY](r_STL_QUERY.md) 및 [SVL\$1QLOG](r_SVL_QLOG.md)와 같은 프로비저닝 전용 뷰에는 쿼리 열이 포함되며 쿼리 열에도 쿼리 식별자가 들어 있습니다. 하지만 SYS 시스템 뷰에 기록된 쿼리 식별자는 프로비저닝 전용 뷰에 기록된 쿼리 식별자와 다릅니다.
SYS 뷰의 query\$1id 열 값과 프로비저닝 전용 뷰의 쿼리 열 값 간의 차이는 다음과 같습니다.
+ SYS 뷰에서 query\$1id 열은 사용자가 제출한 쿼리를 원래 형식으로 기록합니다. Amazon Redshift 최적화 프로그램은 성능 향상을 위해 이러한 쿼리를 하위 쿼리로 분류할 수 있지만, 실행하는 단일 쿼리에는 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)에 여전히 행이 하나뿐입니다. 개별 하위 쿼리는 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)에서 확인할 수 있습니다.
+ 프로비저닝 전용 뷰에서는 쿼리 열에 하위 쿼리 수준의 쿼리가 기록됩니다. Amazon Redshift 최적화 프로그램이 원래 쿼리를 여러 하위 쿼리로 다시 작성하는 경우, 실행하는 단일 쿼리에 대해 쿼리 식별자 값이 서로 다른 여러 행이 [STL\$1QUERY](r_STL_QUERY.md)에 생성됩니다.
모니터링 및 진단 쿼리를 프로비저닝 전용 뷰에서 SYS 뷰로 마이그레이션할 때는 이러한 차이를 고려하여 적절하게 쿼리를 편집하세요. Amazon Redshift의 쿼리 처리 방식에 대한 자세한 내용은 [쿼리 계획 및 실행 워크플로우](c-query-planning.md) 섹션을 참조하세요.
### 예제
Amazon Redshift가 프로비저닝 전용 뷰와 SYS 모니터링 뷰에서 어떻게 다르게 쿼리를 기록하는지 보여주는 예는 다음 샘플 쿼리를 참조하세요. 이 쿼리는 Amazon Redshift에서 실행할 때와 같이 작성된 것입니다.
```
SELECT
s_name
, COUNT(*) AS numwait
FROM
supplier,
lineitem l1,
orders,
nation
WHERE s_suppkey = l1.l_suppkey
AND o_orderkey = l1.l_orderkey
AND o_orderstatus = 'F'
AND l1.l_receiptdate > l1.l_commitdate
AND EXISTS (SELECT
*
FROM
lineitem l2
WHERE l2.l_orderkey = l1.l_orderkey
AND l2.l_suppkey <> l1.l_suppkey )
AND NOT EXISTS (SELECT
*
FROM
lineitem l3
WHERE l3.l_orderkey = l1.l_orderkey
AND l3.l_suppkey <> l1.l_suppkey
AND l3.l_receiptdate > l3.l_commitdate )
AND s_nationkey = n_nationkey
AND n_name = 'UNITED STATES'
GROUP BY
s_name
ORDER BY
numwait DESC
, s_name LIMIT 100;
```
눈에 보이지는 않지만 Amazon Redshift 쿼리 최적화 프로그램은 사용자가 제출한 위 쿼리를 5개의 하위 쿼리로 다시 작성합니다.
첫 번째 하위 쿼리는 임시 테이블을 생성하여 하위 쿼리를 구체화합니다.
```
CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey
, l_suppkey
, s_name ) AS SELECT
l1.l_orderkey
, l1.l_suppkey
, public.supplier.s_name
FROM
public.lineitem AS l1,
public.nation,
public.orders,
public.supplier
WHERE l1.l_commitdate < l1.l_receiptdate
AND l1.l_orderkey = public.orders.o_orderkey
AND l1.l_suppkey = public.supplier.s_suppkey
AND public.nation.n_name = 'UNITED STATES'::CHAR(8)
AND public.nation.n_nationkey = public.supplier.s_nationkey
AND public.orders.o_orderstatus = 'F'::CHAR(1);
```
두 번째 하위 쿼리는 임시 테이블에서 통계를 수집합니다.
```
padb_fetch_sample: select count(*) from volt_tt_606590308b512;
```
세 번째 하위 쿼리는 위에서 만든 임시 테이블을 참조하여 다른 하위 쿼리를 구체화하기 위해 또 다른 임시 테이블을 만듭니다.
```
CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey
, l_suppkey) AS (SELECT
volt_tt_606590308b512.l_orderkey
, volt_tt_606590308b512.l_suppkey
FROM
public.lineitem AS l2,
volt_tt_606590308b512
WHERE l2.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l2.l_orderkey = volt_tt_606590308b512.l_orderkey)
EXCEPT distinct (SELECT volt_tt_606590308b512.l_orderkey, volt_tt_606590308b512.l_suppkey
FROM public.lineitem AS l3, volt_tt_606590308b512
WHERE l3.l_commitdate < l3.l_receiptdate
AND l3.l_suppkey <> volt_tt_606590308b512.l_suppkey
AND l3.l_orderkey = volt_tt_606590308b512.l_orderkey);
```
네 번째 하위 쿼리도 임시 테이블의 통계를 수집합니다.
```
padb_fetch_sample: select count(*) from volt_tt_606590308c2ef
```
마지막 하위 쿼리는 위에서 만든 임시 테이블을 사용하여 출력을 생성합니다.
```
SELECT
volt_tt_606590308b512.s_name AS s_name
, COUNT(*) AS numwait
FROM
volt_tt_606590308b512,
volt_tt_606590308c2ef
WHERE volt_tt_606590308b512.l_orderkey = volt_tt_606590308c2ef.l_orderkey
AND volt_tt_606590308b512.l_suppkey = volt_tt_606590308c2ef.l_suppkey
GROUP BY
1
ORDER BY
2 DESC
, 1 ASC LIMIT 100;
```
프로비저닝 전용 시스템 뷰 STL\$1QUERY에서 Amazon Redshift는 다음과 같이 하위 쿼리 수준에서 5개 행을 기록합니다.
```
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\$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를 분석할 때 다음 사항에 유의하세요.
+ `query_id` 및 `query`와 같은 열의 쿼리 ID 값은 시간이 지남에 따라 재사용될 수 있습니다.
+ `process_id`, `pid`, `session_id`와 같은 열의 프로세스 ID 또는 세션 ID 값은 시간이 지남에 따라 재사용될 수 있습니다.
+ `transaction_id` 및 `xid`와 같은 열의 트랜잭션 ID 값은 고유합니다.
# SVV 메타데이터 뷰
SVV 뷰는 데이터베이스 객체에 대한 정보를 포함하는 Amazon Redshift의 시스템 뷰입니다. 사용자 권한 또는 테이블 이름과 같은 정보는 저장하지만 사용자가 만든 관계와 조인하기 위한 것은 아닙니다.
**참고**
Amazon Redshift는 어떤 이유로든 데이터베이스 응답이 실패할 경우 오류가 아닌 경고를 보고합니다. Amazon Redshift는 데이터 공유에서 객체를 쿼리할 때 오류 메시지를 보내지 않습니다.
**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/ko_kr/redshift/latest/dg/r_SVV_ACTIVE_CURSORS.html)
# SVV\$1ALL\$1COLUMNS
SVV\$1ALL\$1COLUMNS를 사용하여 SVV\$1REDSHIFT\$1COLUMNS에 표시된 대로 Amazon Redshift 테이블의 열 조합과 모든 외부 테이블의 모든 외부 열 통합 목록을 봅니다. 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/ko_kr/redshift/latest/dg/r_SVV_ALL_COLUMNS.html)
## 샘플 쿼리
다음 예에서는 SVV\$1ALL\$1COLUMNS의 출력을 반환합니다.
```
SELECT *
FROM svv_all_columns
WHERE database_name = 'tickit_db'
AND TABLE_NAME = 'tickit_sales_redshift'
ORDER BY COLUMN_NAME,
SCHEMA_NAME
LIMIT 5;
database_name | schema_name | table_name | column_name | ordinal_position | column_default | is_nullable | data_type | character_maximum_length | numeric_precision | numeric_scale | remarks
--------------+-------------+-----------------------+-------------+------------------+----------------+-------------+-----------+--------------------------+-------------------+---------------+---------
tickit_db | public | tickit_sales_redshift | buyerid | 4 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | commission | 9 | | YES | numeric | | 8 | 2 |
tickit_db | public | tickit_sales_redshift | dateid | 7 | | NO | smallint | | 16 | 0 |
tickit_db | public | tickit_sales_redshift | eventid | 5 | | NO | integer | | 32 | 0 |
tickit_db | public | tickit_sales_redshift | listid | 2 | | NO | integer | | 32 | 0 |
```
# SVV\$1ALL\$1SCHEMAS
SVV\$1ALL\$1SCHEMAS를 사용하여 SVV\$1REDSHIFT\$1SCHEMAS에 표시된 Amazon Redshift 스키마의 조합과 모든 데이터베이스의 모든 외부 스키마의 통합 목록을 봅니다. 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/ko_kr/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를 사용하여 SVV\$1REDSHIFT\$1TABLES에 표시된 대로 Amazon Redshift 테이블의 조합과 모든 외부 스키마의 모든 외부 테이블의 통합 목록을 봅니다. 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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_ATTACHED_MASKING_POLICY.html)
## 내부 함수
SVV\$1ATTACHED\$1MASKING\$1POLICY는 다음과 같은 내부 함수를 지원합니다.
### mask\$1get\$1policy\$1for\$1role\$1on\$1column
지정된 열/역할 쌍에 적용되는 가장 높은 우선 순위 정책을 가져옵니다.
#### 구문
```
mask_get_policy_for_role_on_column
(relschema,
relname,
colname,
rolename);
```
#### 파라미터
*relschema*
정책이 있는 스키마의 이름입니다.
*relname*
정책이 있는 테이블의 이름입니다.
*colname*
정책이 연결된 열의 이름입니다.
*rolename*
정책이 연결된 역할의 이름입니다.
### mask\$1get\$1policy\$1for\$1user\$1on\$1column
지정된 열/사용자 쌍에 적용되는 가장 높은 우선 순위 정책을 가져옵니다.
#### 구문
```
mask_get_policy_for_user_on_column
(relschema,
relname,
colname,
username);
```
#### 파라미터
*relschema*
정책이 있는 스키마의 이름입니다.
*relname*
정책이 있는 테이블의 이름입니다.
*colname*
정책이 연결된 열의 이름입니다.
*rolename*
정책이 연결된 사용자의 이름입니다.
# SVV\$1COLUMNS
[Late Binding 보기](r_CREATE_VIEW.md#r_CREATE_VIEW_late-binding-views)를 포함하여 로컬 및 외부 테이블과 보기의 열에 대한 카탈로그 정보를 보려면 SVV\$1COLUMNS를 사용합니다.
기본적으로 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/ko_kr/redshift/latest/dg/r_SVV_COLUMNS.html)
# SVV\$1COLUMN\$1PRIVILEGES
현재 데이터베이스의 사용자, 롤 및 그룹에 명시적으로 부여된 열 권한을 보려면 SVV\$1COLUMN\$1PRIVILEGES를 사용합니다.
SVV\$1COLUMN\$1PRIVILEGES는 다음 사용자에게 표시됩니다.
+ 슈퍼 사용자
+ ACCESS SYSTEM TABLE 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 클러스터의 사용자, 역할 및 그룹에 명시적으로 부여된 datashare 권한을 확인합니다.
SVV\$1DATASHARE\$1PRIVILEGES는 다음 사용자에게 표시됩니다.
+ 슈퍼 사용자
+ ACCESS SYSTEM TABLE 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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를 사용하여 클러스터에서 생성된 datashare 및 클러스터와 공유된 datashare의 목록을 봅니다.
SVV\$1DATASHARES는 다음 사용자에게 표시됩니다.
+ 슈퍼 사용자
+ 데이터 공유 소유자
+ 데이터 공유에 대한 ALTER 또는 USAGE 권한이 있는 사용자
다른 사용자는 행을 볼 수 없습니다. ALTER 및 USAGE 권한에 대한 자세한 내용은 [GRANT](r_GRANT.md) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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)
```
다음 예에서는 아웃바운드 datashare에 대한 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 |
```
다음 예에서는 인바운드 datashare에 대한 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를 사용하여 클러스터에서 생성된 datashare에 대한 소비자 목록을 봅니다.
SVV\$1DATASHARE\$1CONSUMERS는 다음 사용자에게 표시됩니다.
+ 슈퍼 사용자
+ 데이터 공유 소유자
+ 데이터 공유에 대한 ALTER 또는 USAGE 권한이 있는 사용자
다른 사용자는 행을 볼 수 없습니다. ALTER 및 USAGE 권한에 대한 자세한 내용은 [GRANT](r_GRANT.md) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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를 사용하여 클러스터에서 생성되었거나 클러스터와 공유된 모든 datashare의 객체 목록을 봅니다.
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/ko_kr/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/ko_kr/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에 집계 쿼리를 사용하여 데이터베이스, 테이블, 조각 또는 열마다 할당되는 디스크 블록의 수를 결정합니다. 각 데이터 블록이 1MB씩 사용합니다. 또한 [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/ko_kr/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까지의 마지막 3행은 숨겨진 메타데이터 열을 위한 것입니다.)
```
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_SVV_FUNCTION_PRIVILEGES.html)
## 샘플 쿼리
다음 예에서는 SV\$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
데이터 웨어하우스의 GEOGRAPHY 열 목록을 보려면 SVV\$1GEOGRAPHY\$1COLUMNS를 사용하세요. 이 열 목록에는 데이터 공유의 열이 포함됩니다.
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/ko_kr/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
데이터 웨어하우스의 GEOMETRY 열 목록을 보려면 SVV\$1GEOMETRY\$1COLUMNS를 사용하세요. 이 열 목록에는 데이터 공유의 열이 포함됩니다.
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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 통합인 경우에만 채워집니다.
Amazon SageMaker Lakehouse에 AWS Glue 서드 파티 애플리케이션 통합
Amazon SageMaker Lakehouse에 Amazon DynamoDB 통합
자세한 내용은 *AWS Glue 개발자 안내서*의 [제로 ELT 통합](https://docs.aws.amazon.com/glue/latest/dg/zero-etl-using.html)을 참조하세요.
소스에서 대상으로 식별자 값의 변환은 다음 규칙을 따릅니다.
+ 대문자는 소문자로 변환됩니다.
+ 소문자, 숫자 또는 밑줄(\$1)이 아닌 문자는 밑줄(\$1)로 변환됩니다.
+ 기존 식별자 값과 충돌하는 경우 UUID(Universally Unique Identifier)가 새 식별자에 추가됩니다.
+ 소스 식별자 값이 Amazon Redshift 키워드인 경우 접미사 `_redshift`가 새 식별자에 추가됩니다.
변환 후 문자는 소문자, 숫자 또는 밑줄(\$1)이어야 하며 정규식 패턴 `[a-z0-9_]`와 일치해야 합니다. 다음 예제에서는 변환 규칙을 보여줍니다.
| 소스 | 대상 | 참고 |
| --- | --- | --- |
| 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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html)
## 샘플 쿼리
다음 SQL 명령은 통합 로그의 열을 표시합니다.
```
select * from svv_integration_table_state;
integration_id | target_database | schema_name | table_name | table_state |table_last_replicated_checkpoint | reason | last_updated_timestamp |table_rows | table_size | is_history_mode
--------------------------------------+-----------------+-------------+-------------------+--------------+---------------------------------+--------+----------------------------+------------+------------+-----------------
4798e675-8f9f-4686-b05f-92c538e19629 | sample_test2 | sample | SampleTestChannel | Synced | {"txn_seq":3,"txn_id":3122} | | 2023-05-12 12:40:30.656625 | 2 | 16 | f
```
# SVV\$1INTERLEAVED\$1COLUMNS
SVV\$1INTERLEAVED\$1COLUMNS 뷰를 사용하면 인터리브 정렬 키를 사용하는 테이블을 [VACUUM REINDEX](r_VACUUM_command.md#vacuum-reindex)를 사용하여 다시 인덱싱해야 하는지 결정하는 데 도움이 됩니다. VACUUM 실행 주기와 VACUUM REINDEX 실행 시점에 대한 자세한 내용은 [Vacuum 시간 최소화](vacuum-managing-vacuum-times.md) 섹션을 참조하세요.
SVV\$1INTERLEAVED\$1COLUMNS는 슈퍼 사용자에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_MASKING_POLICY.html)
# SVV\$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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_QUERY_INFLIGHT.html)
## 샘플 쿼리
아래의 샘플 출력은 SVV\$1QUERY\$1INFLIGHT 쿼리 자체와 테이블에서 3개의 행으로 나뉜 쿼리 428이라는 현재 실행 중인 2개의 쿼리를 보여 줍니다. (starttime 및 statement 열은 이 샘플 출력에서 잘려 있습니다.)
```
select slice, query, pid, starttime, suspended, trim(text) as statement, sequence
from svv_query_inflight
order by query, sequence;
slice|query| pid | starttime |suspended| statement | sequence
-----+-----+------+----------------------+---------+-----------+---------
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | select ...| 0
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | enueid ...| 1
1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | atname,...| 2
1012 | 429 | 1608 | 2012-04-10 13:53:... | 0 | select ...| 0
(4 rows)
```
# SVV\$1QUERY\$1STATE
SVV\$1QUERY\$1STATE를 사용하여 현재 실행 중인 쿼리의 런타임에 관한 정보를 확인합니다.
SVV\$1QUERY\$1STATE 뷰에는 STV\$1EXEC\$1STATE 테이블의 데이터 하위 집합이 포함됩니다.
SVV\$1QUERY\$1STATE는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
**참고**
이 보기는 프로비저닝된 클러스터를 쿼리할 때만 사용할 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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를 사용합니다. 이 열 집합에는 클러스터의 열과 원격 클러스터에서 제공하는 datashare의 열이 포함됩니다.
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/ko_kr/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\$1REDSHIFT\$1DATABASES를 사용하여 사용자가 액세스할 수 있는 모든 데이터베이스 목록을 봅니다. 여기에는 클러스터의 데이터베이스와 원격 클러스터에서 제공하는 datashare에서 생성된 데이터베이스가 포함됩니다.
기본적으로 SVV\$1REDSHIFT\$1DATABASES는 모든 사용자에게 표시됩니다. 데이터베이스의 메타데이터에 대한 액세스를 제어하려면 프로비저닝된 클러스터 또는 서버리스 작업 그룹에 대한 메타데이터 보안을 활성화합니다. 메타데이터 보안을 사용하면 객체 메타데이터에 대한 보기 권한을 사용자 및 역할별로 구분할 수 있습니다. 자세한 내용은 [메타데이터 보안](t_metadata_security.md) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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를 사용합니다. 이 함수 집합에는 클러스터의 함수와 원격 클러스터에서 제공하는 datashare의 함수가 포함됩니다.
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/ko_kr/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/ko_kr/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를 사용합니다. 이 스키마 집합에는 클러스터의 스키마와 원격 클러스터에서 제공하는 datashare의 스키마가 포함됩니다.
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/ko_kr/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를 사용합니다. 이 테이블 집합에는 클러스터의 테이블과 원격 클러스터에서 제공하는 datashare의 테이블이 포함됩니다.
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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다. 데이터 가시성에 대한 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_RLS_APPLIED_POLICY.html)
## 샘플 쿼리
다음 예는 SVV\$1RLS\$1APPLIED\$1POLICY의 결과를 보여줍니다. SVV\$1RLS\$1APPLIED\$1POLICY를 쿼리하려면 시스템 테이블 액세스 권한이 있어야 합니다.
```
-- 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/ko_kr/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/ko_kr/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
RLS로 보호되는 모든 관계의 목록을 보려면 SVV\$1RLS\$1RELATION을 사용합니다.
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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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 권한이 있는 사용자
다른 사용자는 액세스할 수 있거나 소유한 ID만 볼 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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
현재 연결된 데이터베이스의 테이블 및 구체화된 뷰에 대한 요약 정보를 표시합니다. 뷰는 시스템 테이블을 필터링하고 하나 이상의 데이터 행이 포함된 사용자 정의 테이블과 구체화된 뷰만 표시합니다.
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVV_USER_INFO.html)
## 샘플 쿼리
다음 명령은 SVV\$1USER\$1INFO에서 사용자 정보를 검색합니다.
```
SELECT * FROM SVV_USER_INFO;
```
# SVV\$1VACUUM\$1PROGRESS
이 뷰는 현재 진행 중인 vacuum 작업 완료까지의 예상 시간을 반환합니다.
SVV\$1VACUUM\$1PROGRESS는 슈퍼 사용자에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
SVV\$1VACUUM\$1SUMMARY에 대한 자세한 내용은 [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md) 섹션을 참조하세요.
SVL\$1VACUUM\$1PERCENTAGE에 대한 자세한 내용은 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md) 섹션을 참조하세요.
**참고**
이 보기는 프로비저닝된 클러스터를 쿼리할 때만 사용할 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_SVV_VACUUM_PROGRESS.html)
## 샘플 쿼리
몇 분 간격으로 실행된 다음의 쿼리들은 SALESNEW라는 이름의 큰 테이블이 vacuum되고 있음을 보여 줍니다.
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
--------------+-------------------------------+-------------------------
salesnew | Vacuum: initialize salesnew |
(1 row)
...
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+------------------------+-------------------------
salesnew | Vacuum salesnew sort | 33m 21s
(1 row)
```
다음 쿼리는 현재 진행 중인 vacuum 작업이 없음을 보여 줍니다. vacuum될 마지막 테이블은 SALES 테이블이었습니다.
```
select * from svv_vacuum_progress;
table_name | status | time_remaining_estimate
-------------+----------+-------------------------
sales | Complete |
(1 row)
```
# SVV\$1VACUUM\$1SUMMARY
SVV\$1VACUUM\$1SUMMARY 뷰는 STL\$1VACUUM, STL\$1QUERY 및 STV\$1TBL\$1PERM 테이블을 조인하여 시스템에 의해 기록되는 vacuum 작업에 대한 정보를 요약합니다. 이 뷰는 vacuum 트랜잭션마다 테이블당 하나의 행을 반환합니다. 이 뷰는 작업 경과 시간, 생성된 정렬 파티션의 수, 필요한 병합 증분의 수, 행에 있는 델타 및 작업 수행 전후의 블록 수를 기록합니다.
SVV\$1VACUUM\$1SUMMARY는 슈퍼 사용자에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
SVV\$1VACUUM\$1PROGRESS에 대한 자세한 내용은 [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md) 섹션을 참조하세요.
SVL\$1VACUUM\$1PERCENTAGE에 대한 자세한 내용은 [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md) 섹션을 참조하세요.
**참고**
이 보기는 프로비저닝된 클러스터를 쿼리할 때만 사용할 수 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_SVV_VACUUM_SUMMARY.html)
## 샘플 쿼리
다음 쿼리는 세 가지 테이블에서의 vacuum 작업에 대한 통계를 반환합니다. SALES 테이블은 두 번 vacuum되었습니다.
```
select table_name, xid, sort_partitions as parts, merge_increments as merges,
elapsed_time, row_delta, sortedrow_delta as sorted_delta, block_delta
from svv_vacuum_summary
order by xid;
table_ | xid |parts|merges| elapsed_ | row_ | sorted_ | block_
name | | | | time | delta | delta | delta
--------+------+-----+------+----------+---------+---------+--------
users | 2985 | 1 | 1 | 61919653 | 0 | 49990 | 20
category| 3982 | 1 | 1 | 24136484 | 0 | 11 | 0
sales | 3992 | 2 | 1 | 71736163 | 0 | 1207192 | 32
sales | 4000 | 1 | 1 | 15363010 | -851648 | -851648 | -140
(4 rows)
```
# SYS 모니터링 뷰
*모니터링 뷰*는 프로비저닝된 클러스터 및 서버리스 작업 그룹의 쿼리 및 워크로드 리소스 사용량을 모니터링하는 데 사용되는 Amazon Redshift Serverless의 시스템 뷰입니다. 이러한 보기는 `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/ko_kr/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/ko_kr/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\$1APPLIED\$1MASKING\$1POLICY\$1LOG는 `sys:secadmin` 역할을 가진 사용자에게는 표시되지 않습니다.
동적 데이터 마스킹에 대한 자세한 내용은 [동적 데이터 마스킹](t_ddm.md) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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을 사용하여 Autonomics라고도 하는 자동 최적화를 위해 Amazon Redshift가 실행하는 작업에 대한 세부 정보를 볼 수 있습니다. 자동 최적화에 대한 자세한 내용은 [자동 데이터베이스 최적화](c_autonomics.md) 섹션을 참조하세요.
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/ko_kr/redshift/latest/dg/SYS_AUTOMATIC_OPTIMIZATION.html)
## 사용 노트
primary 또는 primary-scale의 컴퓨팅 리소스를 구분하지 않으므로 서버리스 클러스터의 경우 compute\$1type 열이 비어 있습니다. 서버리스 클러스터 컴퓨팅 리소스는 Redshift 처리 장치(RPU) 사용량으로 측정됩니다. 자세한 내용은 [Amazon Redshift Serverless의 컴퓨팅 용량](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-capacity.html)을 참조하세요.
## 예제
다음 쿼리는 테이블 155259에서 수행된 자동 최적화를 표시합니다.
```
SELECT pid, trim(task_type) as task_type,
trim(database) as database,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE object_ids like '%155259%'
AND status = 'Task completed successfully';
task_type | database | status | event | event_time
------------+----------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
```
다음 쿼리는 실행된 모든 자동 "VacuumSort" 최적화를 보여줍니다. "VacuumSort"에 대한 자세한 내용은 [자동 테이블 정렬](t_Reclaiming_storage_space202.md#automatic-table-sort) 섹션을 참조하세요.
```
SELECT trim(task_type) as task_type,
trim(database) as database,
trim(object_type) as object_type,
trim(object_ids) as object_ids,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE task_type like '%VacuumSort%'
AND status = 'Task completed successfully';
task_type | database | object_type | object_ids | status | event | event_time
------------+----------------+-------------+------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | table | 155301 | Task completed successfully | Completed | 2025-12-22 07:14:00.065391
VacuumSort | tpcds_100g_oob | table | 155303 | Task completed successfully | Completed | 2025-12-22 07:14:09.158251
VacuumSort | tpcds_100g_oob | table | 155291 | Task completed successfully | Completed | 2025-12-22 07:17:06.61164
VacuumSort | tpcds_100g_oob | table | 155293 | Task completed successfully | Completed | 2025-12-22 07:17:37.015069
VacuumSort | tpcds_100g_oob | table | 155281 | Task completed successfully | Completed | 2025-12-22 07:18:54.903935
VacuumSort | tpcds_100g_oob | table | 155279 | Task completed successfully | Completed | 2025-12-22 07:20:13.960002
VacuumSort | tpcds_100g_oob | table | 155271 | Task completed successfully | Completed | 2025-12-22 07:21:26.095549
VacuumSort | tpcds_100g_oob | table | 155267 | Task completed successfully | Completed | 2025-12-22 07:22:48.119249
VacuumSort | tpcds_100g_oob | table | 155269 | Task completed successfully | Completed | 2025-12-22 07:24:12.010424
VacuumSort | tpcds_100g_oob | table | 155263 | Task completed successfully | Completed | 2025-12-22 07:25:35.958388
VacuumSort | tpcds_100g_oob | table | 155265 | Task completed successfully | Completed | 2025-12-22 07:26:40.580395
VacuumSort | tpcds_100g_oob | table | 155259 | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
(12 rows)
```
# SYS\$1AUTO\$1TABLE\$1OPTIMIZATION
자동 최적화를 위해 정의된 테이블에 Amazon Redshift에서 수행한 자동화된 작업을 기록합니다.
SYS\$1AUTO\$1TABLE\$1OPTIMIZATION은 슈퍼유저에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/SYS_COPY_JOB_INFO.html)
# SYS\$1COPY\$1REPLACEMENTS
ACCEPTINVCHARS 옵션과 함께 [COPY](r_COPY.md) 명령을 실행하여 잘못된 UTF-8 문자를 대체했을 때 기록되는 로그를 표시합니다. 적어도 1개 이상 대체가 필요했던 각 노드 조각에서 첫 번째 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/ko_kr/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
생산자 클러스터와 소비자 클러스터 모두에서 datashare의 변경 내용을 추적하기 위한 통합 뷰를 기록합니다.
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/ko_kr/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/ko_kr/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
datashare의 활동과 사용량을 기록합니다. 이 뷰는 소비자 클러스터에만 관련이 있습니다.
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/ko_kr/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
datashare의 활동과 사용량을 기록합니다. 이 뷰는 생산자 클러스터에만 관련이 있습니다.
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/ko_kr/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로 세그먼트 수준에서 쿼리에 대한 세부 정보를 봅니다. 각 행은 처리된 행 수, 처리된 바이트 수, Amazon S3에 있는 외부 테이블의 파티션 정보와 같은 세부 정보가 포함된 특정 WLM 쿼리의 세그먼트를 나타냅니다. 이 보기의 각 행은 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/ko_kr/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를 쿼리하여 적색편이 스펙트럼 스캔 오류에 대한 정보를 얻을 수 있습니다. 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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)
```
레코드가 이 시스템 뷰의 로그 파일에 작성된다고 해서 저장 트랜잭션(containing transaction)에서 로드가 성공적으로 커밋되었다는 것을 의미하지는 않습니다. 로드 커밋 여부를 확인하려면 STL\$1UTILITYTEXT 뷰에 대한 쿼리를 실행하여 COPY 트랜잭션과 일치하는 COMMIT 레코드를 찾습니다. 예를 들어 다음 쿼리는 STL\$1UTILITYTEXT에 대한 하위 쿼리를 기준으로 SYS\$1LOAD\$1DETAIL 테이블과 STL\$1QUERY 테이블을 조인합니다.
```
select l.query_id,rtrim(l.file_name),q.transaction_id
from sys_load_detail l, sys_query_text q
where l.query_id=q.query_id
and exists
(select xid from stl_utilitytext where xid=q.transaction_id and rtrim("text")='COMMIT');
query_id | rtrim | transaction_id
----------+---------------------------+-----------------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
# SYS\$1LUDF\$1DETAIL
SYS\$1LUDF\$1DETAIL은 특정 쿼리에 사용된 Lambda 사용자 정의 함수(LUDF)에 대한 정보와 지표를 기록합니다.
SYS\$1LUDF\$1DETAIL은 수퍼유저에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 명령과 완료된 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/ko_kr/redshift/latest/dg/SYS_LOAD_ERROR_DETAIL.html)
## 샘플 쿼리
다음 쿼리는 특정 쿼리에 대한 copy 명령의 로드 오류 세부 정보를 보여줍니다.
```
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 명령과 완료된 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/ko_kr/redshift/latest/dg/SYS_LOAD_HISTORY.html)
## 샘플 쿼리
다음 쿼리는 특정 copy 명령의 로드된 행, 바이트 수, 테이블 및 데이터 소스를 보여줍니다.
```
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
```
다음 쿼리는 copy 명령의 로드된 행, 바이트 수, 테이블 및 데이터 소스를 보여줍니다.
```
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
```
다음 쿼리는 copy 명령의 일별 로드된 행 및 바이트 수를 보여줍니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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;
```
다음은 가장 최근 SELECT 쿼리 10개를 나열하는 쿼리입니다.
```
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 값이 포함됩니다. `SELECT * FROM test_table WHERE col1=1;` 및 `SELECT * FROM test_table WHERE col1=2;`에는 user\$1query\$1hash 값이 다르지만 두 쿼리가 쿼리 리터럴 1과 2 외부에서 동일하므로 generic\$1query\$1hash 값은 동일합니다.
# SYS\$1QUERY\$1TEXT
SYS\$1QUERY\$1TEXT를 사용하여 모든 쿼리의 쿼리 텍스트를 볼 수 있습니다. 각 행은 시퀀스 번호 0으로 시작하는 최대 4,000자의 쿼리 텍스트를 나타냅니다. 쿼리 명령문이 4,000자를 초과하는 경우 각 행의 시퀀스 번호를 증가시켜 명령문에 대한 추가 행이 로깅됩니다. 이 뷰는 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/ko_kr/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/ko_kr/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
RA3 노드로의 클래식 크기 조정 중에 클러스터 내 각 테이블의 마이그레이션 진행 상황을 모니터링하려면 SYS\$1RESTORE\$1LOG를 사용합니다. 이는 크기 조정 작업 중 데이터 마이그레이션의 과거 처리량을 캡처합니다. 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/ko_kr/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/ko_kr/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/ko_kr/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 클러스터에는 적용되지 않습니다.
이 보기에는 쿼리를 처리하는 데 사용되는 컴퓨팅 용량과 1분 단위로 사용되는 Amazon Redshift 관리형 스토리지의 양을 포함한 서버리스 사용량 요약이 포함되어 있습니다. 컴퓨팅 용량은 Redshift 처리 장치(RPU)로 측정되며 실행하는 워크로드에 대해 초당 RPU(초) 단위로 측정됩니다. RPU는 데이터 웨어하우스에 로드되거나, Amazon S3 데이터 레이크에서 쿼리되거나, 연합 쿼리를 사용하여 운영 데이터베이스에서 액세스되는 데이터에 대한 쿼리를 처리하는 데 사용됩니다. Amazon Redshift Serverless는 7일 동안 SYS\$1SERVERLESS\$1USAGE에 정보를 보관합니다.
컴퓨팅 비용 청구에 대한 예시는 [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/ko_kr/redshift/latest/dg/SYS_SERVERLESS_USAGE.html)
## 사용 노트
+ compute\$1seconds가 0이지만 charged\$1seconds가 0보다 크거나 그 반대의 경우가 있습니다. 이는 데이터가 시스템 뷰에 기록되는 방식에 따른 정상적인 동작입니다. 서버리스 사용량 세부 정보를 보다 정확하게 표시하려면 데이터를 집계하는 것이 좋습니다.
## 예제
charge\$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/ko_kr/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 로드에 대한 자세한 내용은 [Amazon Redshift에 shapefile 로드](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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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에 로깅 및 경고 메시지를 추가하므로 0으로 나누기 연산은 오류 메시지와 함께 중단되는 대신 경고 메시지를 생성합니다.
```
-- 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 문에서 생성되는 파일마다 행 1개를 기록합니다. 예를 들어 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/ko_kr/redshift/latest/dg/SYS_UNLOAD_DETAIL.html)
## 샘플 쿼리
다음 쿼리는 unload 명령의 형식, 행 및 파일 수를 비롯하여 언로드된 쿼리에 대한 세부 정보를 보여줍니다.
```
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 명령과 완료된 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/ko_kr/redshift/latest/dg/SYS_UNLOAD_HISTORY.html)
## 샘플 쿼리
다음 쿼리는 unload 명령의 형식, 행 및 파일 수를 비롯하여 언로드된 쿼리에 대한 세부 정보를 보여줍니다.
```
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/ko_kr/redshift/latest/dg/SYS_USERLOG.html)
## 샘플 쿼리
다음은 사용자 작업 4개를 실행한 후 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/ko_kr/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일 미만의 로그 기록이 있습니다. 로그 보존을 위해 별도의 조치를 취할 필요는 없지만 로그 데이터를 7일 이상 보관하고 싶다면 정기적으로 다른 테이블에 복사하거나 Amazon S3로 언로드해야 합니다.
**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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_ALERT_EVENT_LOG.html)
## 사용 노트
STL\$1ALERT\$1EVENT\$1LOG는 쿼리에서 잠재적 문제를 식별한 후 [쿼리 성능 튜닝](c-optimizing-query-performance.md)의 모범 사례에 따라 데이터베이스 설계를 최적화하여 쿼리를 재작성하는 데 사용할 수 있습니다. STL\$1ALERT\$1EVENT\$1LOG는 다음과 같은 알림을 기록합니다.
+ **통계 누락**
통계가 누락된 경우에는 데이터 로드 또는 중요한 업데이트에 이어 ANALYZE를 실행한 다음 COPY 작업에 STATUPDATE를 사용하세요. 자세한 내용은 [Amazon Redshift 쿼리 설계 모범 사례](c_designing-queries-best-practices.md) 섹션을 참조하세요.
+ **중첩 루프**
중첩 루프는 일반적으로 데카르트 곱입니다. 이때는 쿼리를 평가하여 참여하는 테이블이 모두 효율적으로 조인되었는지 확인하세요.
+ **선택의 폭이 제한적인 필터**
반환되는 행과 스캔되는 행의 비율은 0.05미만입니다. 스캔되는 행은 `rows_pre_user_filter` 값이고, 반환되는 행은 [STL\$1SCAN](r_STL_SCAN.md) 시스템 뷰의 rows 값입니다. 이 알림은 쿼리가 결과 집합을 확인하기 위해 비정상적으로 많은 수의 행을 스캔하고 있다는 것을 의미합니다. 이러한 문제는 정렬 키가 누락되었거나 잘못되었을 때 발생할 수 있습니다. 자세한 내용은 [정렬 키](t_Sorting_data.md) 섹션을 참조하세요.
+ **지나치게 많은 고스트 행 **
스캔 작업이 정리가 아닌 삭제된 것으로 표시되었거나, 혹은 커밋되지 않고 삽입된 비교적 다수의 행을 건너뛰었습니다. 자세한 내용은 [테이블 Vacuum](t_Reclaiming_storage_space202.md) 섹션을 참조하세요.
+ **다수의 행 분산 **
100만 개가 넘는 행이 해시 조인 또는 집계를 위해 재분산되었습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
+ **다수의 행 브로드캐스팅 **
100만 개가 넘는 행이 해시 조인을 위해 브로드캐스팅되었습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
+ **직렬 실행 **
쿼리 계획에서 DS\$1DIST\$1ALL\$1INNER 재분산 스타일이 지정되면서 내부 테이블 전체가 단일 조각으로 재분산되었기 때문에 직렬 실행을 피할 수 없습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
## 샘플 쿼리
다음은 4개 쿼리의 알림 이벤트를 나타낸 쿼리입니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_BCAST.html)
### 샘플 쿼리
다음은 패킷이 1개 이상이고, 시작 시간부터 종료 시간까지 차이가 1초 이상인 쿼리의 브로드캐스팅 정보를 반환하는 예입니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/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 문 4개를 보여주는 출력 샘플입니다. 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을 실행하기 전에 SQL 클라이언트에서 모든 (`\n`) 특수 문자를 줄 바꿈으로 바꿉니다. 다음 SELECT 문의 결과는 `query_statement` 필드에서 SQL을 재구성하기 위해 세 개의 행을 순서대로 조합합니다.
```
SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement
FROM stl_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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_DIST.html)
## 샘플 쿼리
다음은 패킷이 1개 이상이고, 지속 시간이 0보다 큰 쿼리의 분산 정보를 반환하는 예입니다.
```
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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_EXPLAIN.html)
## 샘플 쿼리
집계 조인 쿼리의 EXPLAIN 출력이 다음과 같다고 가정하겠습니다.
```
explain select avg(datediff(day, listtime, saletime)) as avgwait
from sales, listing where sales.listid = listing.listid;
QUERY PLAN
------------------------------------------------------------------------------
XN Aggregate (cost=6350.30..6350.31 rows=1 width=16)
-> XN Hash Join DS_DIST_NONE (cost=47.08..6340.89 rows=3766 width=16)
Hash Cond: ("outer".listid = "inner".listid)
-> XN Seq Scan on listing (cost=0.00..1924.97 rows=192497 width=12)
-> XN Hash (cost=37.66..37.66 rows=3766 width=12)
-> XN Seq Scan on sales (cost=0.00..37.66 rows=3766 width=12)
(6 rows)
```
이 쿼리를 실행하고, 쿼리 ID가 10이라면 STL\$1EXPLAIN 테이블을 사용하여 EXPLAIN 명령이 반환하는 것과 동일한 유형의 정보를 볼 수 있습니다.
```
select query,nodeid,parentid,substring(plannode from 1 for 30),
substring(info from 1 for 20) from stl_explain
where query=10 order by 1,2;
query| nodeid |parentid| substring | substring
-----+--------+--------+--------------------------------+-------------------
10 | 1 | 0 |XN Aggregate (cost=6717.61..6 |
10 | 2 | 1 | -> XN Merge Join DS_DIST_NO | Merge Cond:("outer"
10 | 3 | 2 | -> XN Seq Scan on lis |
10 | 4 | 2 | -> XN Seq Scan on sal |
(4 rows)
```
다음과 같은 쿼리를 가정합니다.
```
select event.eventid, sum(pricepaid)
from event, sales
where event.eventid=sales.eventid
group by event.eventid order by 2 desc;
eventid | sum
--------+----------
289 | 51846.00
7895 | 51049.00
1602 | 50301.00
851 | 49956.00
7315 | 49823.00
...
```
이 쿼리의 ID가 15라면 다음과 같은 시스템 보기 쿼리에서 이전에 완료한 계획 노드가 반환됩니다. 이때 노드 순서가 반전되면서 실제 실행 순서를 표시합니다.
```
select query,nodeid,parentid,substring(plannode from 1 for 56)
from stl_explain where query=15 order by 1, 2 desc;
query|nodeid|parentid| substring
-----+------+--------+--------------------------------------------------------
15 | 8 | 7 | -> XN Seq Scan on eve
15 | 7 | 5 | -> XN Hash(cost=87.98..87.9
15 | 6 | 5 | -> XN Seq Scan on sales(cos
15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos
15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07..
15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871
15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197.
15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87
(8 rows)
```
다음은 창 함수가 포함된 모든 쿼리 계획의 쿼리 ID를 가져오는 쿼리입니다.
```
select query, trim(plannode) from stl_explain
where plannode like '%Window%';
query| btrim
-----+------------------------------------------------------------------------
26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33)
(2 rows)
```
# STL\$1FILE\$1SCAN
COPY 명령을 사용하여 데이터를 로드하면서 Amazon Redshift가 읽은 파일을 반환합니다.
이 뷰에 대해 쿼리를 실행하면 데이터 로드 오류를 해결하는 데 도움이 될 수 있습니다. 특히 STL\$1FILE\$1SCAN은 병렬 데이터 로드 시 문제를 찾아내는 데 효과적입니다. 병렬 데이터 로드는 단일 COPY 명령으로 다수의 파일을 로드하기 때문입니다.
STL\$1FILE\$1SCAN은 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
**참고**
STL\$1FILE\$1SCAN에는 기본 프로비저닝된 클러스터에서 실행되는 쿼리만 포함됩니다. 동시성 크기 조정 클러스터 또는 서버리스 네임스페이스에서 실행되는 쿼리는 포함되지 않습니다. 기본 클러스터, 동시성 크기 조정 클러스터, 서버리스 네임스페이스 모두에서 실행되는 쿼리에 대한 설명 계획에 액세스하려면 SYS 모니터링 뷰인 [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)을 사용하는 것이 좋습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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
LIMIT 절을 SELECT 쿼리에서 사용할 때 발생하는 실행 단계를 분석합니다.
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/ko_kr/redshift/latest/dg/r_STL_LIMIT.html)
## 샘플 쿼리
다음 예에서는 STL\$1LIMIT에 행을 생성할 목적으로 먼저 VENUE 테이블에 대해 LIMIT 절을 사용하여 다음 쿼리를 실행합니다.
```
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)
```
마지막으로 다음 쿼리를 실행하여 LIMIT 쿼리에 대한 정보를 STL\$1LIMIT 테이블에서 반환합니다.
```
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/ko_kr/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)
```
레코드가 이 시스템 뷰의 로그 파일에 작성된다고 해서 저장 트랜잭션(containing transaction)에서 로드가 성공적으로 커밋되었다는 것을 의미하지는 않습니다. 로드 커밋 여부를 확인하려면 STL\$1UTILITYTEXT 뷰에 대한 쿼리를 실행하여 COPY 트랜잭션과 일치하는 COMMIT 레코드를 찾습니다. 예를 들어 다음 쿼리는 STL\$1UTILITYTEXT에 대한 하위 쿼리를 기준으로 STL\$1LOAD\$1COMMITS 테이블과 STL\$1QUERY 테이블을 조인합니다.
```
select l.query,rtrim(l.filename),q.xid
from stl_load_commits l, stl_query q
where l.query=q.query
and exists
(select xid from stl_utilitytext where xid=q.xid and rtrim("text")='COMMIT');
query | rtrim | xid
-------+---------------------------+-------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
다음 예에서는 is\$1partial 및 start\$1offset 열 값을 강조 표시합니다.
```
-- Single large file copy without scan range
SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id();
1
-- Single large uncompressed, delimited file copy with scan range
SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id();
16
-- Scan range offset logging in the file at 64MB boundary.
SELECT start_offset FROM stl_load_commits
WHERE query = pg_last_copy_id() ORDER BY start_offset;
0
67108864
134217728
201326592
268435456
335544320
402653184
469762048
536870912
603979776
671088640
738197504
805306368
872415232
939524096
1006632960
```
# STL\$1LOAD\$1ERRORS
모든 Amazon Redshift 로드 오류에 대한 레코드를 표시합니다.
STL\$1LOAD\$1ERRORS에는 모든 Amazon Redshift 로드 오류에 대한 이력이 저장됩니다. 가능한 로드 오류와 설명을 나타낸 전체 목록은 [로드 오류 참조](r_Load_Error_Reference.md) 섹션을 참조하세요.
구문 분석 오류가 발생한 경우 STL\$1LOAD\$1ERRORS에 대한 쿼리를 실행하여 오류에 대한 일반 정보를 확인한 이후에도 정확한 데이터 행과 열 등을 포함하여 그 밖의 세부 정보를 알고 싶다면 [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md)에 대한 쿼리를 실행합니다.
STL\$1LOAD\$1ERRORS는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
**참고**
STL\$1LOAD\$1ERRORS에는 기본 프로비저닝된 클러스터에서 실행되는 쿼리만 포함됩니다. 동시성 크기 조정 클러스터 또는 서버리스 네임스페이스에서 실행되는 쿼리는 포함되지 않습니다. 기본 클러스터, 동시성 크기 조정 클러스터, 서버리스 네임스페이스 모두에서 실행되는 쿼리에 대한 설명 계획에 액세스하려면 SYS 모니터링 뷰인 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)을 사용하는 것이 좋습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 테이블에서 발생한 마지막 로드 오류를 반환합니다. 발생한 로드 오류가 없는 경우에는 쿼리가 0개의 행을 반환합니다. 이번 예에서는 쿼리가 단일 오류를 반환합니다.
```
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 명령을 사용해 테이블에 로드할 때 발생한 데이터 구문 분석 오류의 로그를 표시합니다. 디스크 공간을 절약할 수 있도록 각 로드 작업마다 노드 조각 1개당 최대 20개의 오류가 기록됩니다.
구문 분석 오류는 Amazon Redshift가 데이터를 테이블에 로드하면서 데이터 행의 필드 구문을 분석할 수 없을 때 발생합니다. 예를 들어 테이블 열에는 정수 데이터 형식이 필요한데 데이터 파일의 해당 필드에는 문자열이 포함되어 있으면 구문 분석 오류가 발생합니다.
구문 분석 오류가 발생한 경우 [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md)에 대한 쿼리를 실행하여 오류에 대한 일반 정보를 확인한 이후에도 정확한 데이터 행과 열 등을 포함하여 그 밖의 세부 정보를 알고 싶다면 STL\$1LOADERROR\$1DETAIL에 대한 쿼리를 실행하세요.
STL\$1LOADERROR\$1DETAIL 뷰에는 구문 분석 오류가 발생한 열을 포함하여 그 전의 모든 데이터 열이 포함됩니다. VALUE 필드에서는 정확히 오류까지 구문 분석된 열을 포함하여 이 열에서 실제로 구문 분석된 데이터 값을 확인할 수 있습니다.
이 뷰는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
**참고**
STL\$1LOADERROR\$1DETAIL에는 기본 프로비저닝된 클러스터에서 실행되는 쿼리만 포함됩니다. 동시성 크기 조정 클러스터 또는 서버리스 네임스페이스에서 실행되는 쿼리는 포함되지 않습니다. 기본 클러스터, 동시성 크기 조정 클러스터, 서버리스 네임스페이스 모두에서 실행되는 쿼리에 대한 설명 계획에 액세스하려면 SYS 모니터링 뷰인 [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)을 사용하는 것이 좋습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_STL_LOADERROR_DETAIL.html)
## 샘플 쿼리
다음은 STL\$1LOAD\$1ERRORS를 STL\$1LOADERROR\$1DETAIL로 조인하여 테이블 ID가 100133인 EVENT 테이블에 데이터를 로드할 때 발생한 구문 분석 오류의 세부 정보를 표시하는 쿼리입니다.
```
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;
```
다음은 오류가 발생한 열을 포함하여 성공적으로 로드된 열을 나타낸 샘플 출력입니다. 이 예에서는 정수가 필요한 필드에서 문자열이 잘못 구분 분석되어 세 번째 열에서 오류가 발생하기 전에 성공적으로 로드된 열이 2개입니다. 필드에 필요했던 형식은 정수이기 때문에 비초기화 데이터(uninitialized data)인 문자열 "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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_NESTLOOP.html)
## 샘플 쿼리
다음 쿼리는 CATEGORY 테이블을 조인하지 않아서 부분적으로 데카르트 곱을 산출하지만 권장하지는 않습니다. 그럼에도 불구하고 여기에 표시하는 이유는 중첩 루프를 설명하기 위해서입니다.
```
select count(event.eventname), event.eventname, category.catname, date.caldate
from event, category, date
where event.dateid = date.dateid
group by event.eventname, category.catname, date.caldate;
```
다음은 위 쿼리의 결과를 STL\$1NESTLOOP 뷰에 표시하는 쿼리입니다.
```
select query, slice, segment as seg, step,
datediff(msec, starttime, endtime) as duration, tasknum, rows, tbl
from stl_nestloop
where query = pg_last_query_id();
```
```
query | slice | seg | step | duration | tasknum | rows | tbl
-------+-------+-----+------+----------+---------+-------+-----
6028 | 0 | 4 | 5 | 41 | 22 | 24277 | 240
6028 | 1 | 4 | 5 | 26 | 23 | 24189 | 240
6028 | 3 | 4 | 5 | 25 | 23 | 24376 | 240
6028 | 2 | 4 | 5 | 54 | 22 | 23936 | 240
```
# STL\$1PARSE
로딩을 위한 문자열을 이진 값으로 구문 분석하는 쿼리 단계를 분석합니다.
STL\$1PARSE는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
**참고**
STL\$1PARSE에는 기본 프로비저닝된 클러스터에서 실행되는 쿼리만 포함됩니다. 동시성 크기 조정 클러스터 또는 서버리스 네임스페이스에서 실행되는 쿼리는 포함되지 않습니다. 기본 클러스터, 동시성 크기 조정 클러스터, 서버리스 네임스페이스 모두에서 실행되는 쿼리에 대한 설명 계획에 액세스하려면 SYS 모니터링 뷰인 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)을 사용하는 것이 좋습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_PLAN_INFO.html)
## 샘플 쿼리
다음은 단순한 SELECT 쿼리에서 EXPLAIN 명령을 사용하여 반환되는 쿼리 계획과 STL\$1PLAN\$1INFO 뷰에 대한 쿼리를 실행하여 반환되는 쿼리 계획을 비교하는 예입니다.
```
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/ko_kr/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 모니터링 뷰를 사용하는 것이 좋습니다.
쿼리 텍스트 길이가 4,000자를 초과하는 경우 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/ko_kr/redshift/latest/dg/r_STL_QUERY.html)
## 샘플 쿼리
다음은 가장 최근 쿼리 5개를 나열하는 쿼리입니다.
```
select query, trim(querytxt) as sqlquery
from stl_query
order by query desc limit 5;
query | sqlquery
------+--------------------------------------------------
129 | select query, trim(querytxt) from stl_query order by query;
128 | select node from stv_disk_read_speeds;
127 | select system_status from stv_gui_status
126 | select * from systable_topology order by slice
125 | load global dict registry
(5 rows)
```
다음은 2013년 2월 15일에 실행한 쿼리의 경과 시간을 내림차순으로 반환하는 쿼리입니다.
```
select query, datediff(seconds, starttime, endtime),
trim(querytxt) as sqlquery
from stl_query
where starttime >= '2013-02-15 00:00' and endtime < '2013-02-16 00:00'
order by date_diff desc;
query | date_diff | sqlquery
-------+-----------+-------------------------------------------
55 | 119 | padb_fetch_sample: select count(*) from category
121 | 9 | select * from svl_query_summary;
181 | 6 | select * from svl_query_summary where query in(179,178);
172 | 5 | select * from svl_query_summary where query=148;
...
(189 rows)
```
다음 쿼리는 쿼리에 대한 대기열 시간 및 실행 시간을 보여줍니다. 동시성 확장 클러스터에서 실행된 `concurrency_scaling_status = 1`의 쿼리입니다. 기본 클러스터에서 실행된 다른 모든 쿼리입니다.
```
SELECT w.service_class AS queue
, q.concurrency_scaling_status
, COUNT( * ) AS queries
, SUM( q.aborted ) AS aborted
, SUM( ROUND( total_queue_time::NUMERIC / 1000000,2 ) ) AS queue_secs
, SUM( ROUND( total_exec_time::NUMERIC / 1000000,2 ) ) AS exec_secs
FROM stl_query q
JOIN stl_wlm_query w
USING (userid,query)
WHERE q.userid > 1
AND service_class > 5
AND q.starttime > '2019-03-01 16:38:00'
AND q.endtime < '2019-03-01 17:40:00'
GROUP BY 1,2
ORDER BY 1,2;
```
# STL\$1QUERY\$1METRICS
사용자 정의 쿼리 대기열(서비스 클래스)에서 실행을 마친 쿼리의 지표 정보(처리된 행의 수, CPU 사용량, 입/출력, 디스크 사용량)가 저장됩니다. 현재 실행 중인 활성 쿼리의 지표를 보려면 [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md) 시스템 뷰를 참조하세요.
쿼리 지표는 1초 간격으로 샘플링됩니다. 결과적으로 동일한 쿼리라고 해도 다르게 실행하면 약간 다른 시간을 반환할 수 있습니다. 또한 1초 이내에 실행되는 쿼리 세그먼트는 기록되지 않을 수도 있습니다.
STL\$1QUERY\$1METRICS은 지표를 쿼리, 세그먼트 및 단계 수준으로 추적 및 집계합니다. 쿼리 세그먼트 및 단계에 대한 자세한 내용은 [쿼리 계획 및 실행 워크플로우](c-query-planning.md) 섹션을 참조하세요. 노드 조각에서 합산되는 지표도 `max_rows`, `cpu_time` 등 매우 많습니다. 노드 조각에 대한 자세한 내용은 [데이터 웨어하우스 시스템 아키텍처](c_high_level_system_architecture.md) 섹션을 참조하세요.
행이 지표를 보고하는 수준을 확인하고 싶으면 다음과 같이 `segment` 열과 `step_type` 열을 살펴보세요.
+ `segment` 열과 `step_type` 열의 값이 모두 `-1`이면 행이 쿼리 수준에서 지표를 보고합니다.
+ `segment` 열이 `-1`이 아니고, `step_type` 열이 `-1`이면 행이 세그먼트 수준에서 지표를 보고합니다.
+ `segment` 열과 `step_type` 열의 값이 모두 `-1`이 아니면 행이 단계 수준에서 지표를 보고합니다.
[SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md) 뷰와 [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md) 뷰는 이 뷰의 데이터를 집계하여 액세스가 가능한 형식으로 정보를 제공합니다.
STL\$1QUERY\$1METRS는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](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/ko_kr/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
```
중첩 루프 조인을 사용하여 반환된 행의 수가 100만 개가 넘는 활성 쿼리를 찾으려면 다음과 같이 쿼리를 실행합니다.
```
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 모니터링 뷰를 사용하는 것이 좋습니다.
쿼리 텍스트 길이가 4,000자를 초과하는 경우 STL\$1QUERYTEXT는 잘린 데이터만 표시합니다. 전체 쿼리 텍스트를 얻으려면 행 전체에 걸쳐 쿼리 텍스트에 UNION을 사용하면 됩니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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` 열의 1개 이상의 부분에서 SQL을 생성합니다. 재구성된 SQL을 실행하기 전에 모든 (`\n`) 특수 문자를 줄 바꿈으로 바꿉니다. 다음 SELECT 문의 결과는 `query_statement` 필드에서 재구성된 SQL의 행입니다.
```
SELECT query, LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement, COUNT(*) as row_count
FROM stl_querytext GROUP BY query ORDER BY query desc;
```
예를 들어 다음 쿼리는 열 3개를 선택합니다. 쿼리 자체는 200자 이상이며 STL\$1QUERYTEXT에 여러 부분으로 저장됩니다.
```
select
1 AS a0123456789012345678901234567890123456789012345678901234567890,
2 AS b0123456789012345678901234567890123456789012345678901234567890,
3 AS b012345678901234567890123456789012345678901234
FROM stl_querytext;
```
이 예제에서 이 쿼리는 STL\$1QUERYTEXT의 `text` 열에 많은 두 부분(행)으로 저장됩니다.
```
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 문자를 대체했을 때 기록되는 로그를 표시합니다. 적어도 1개 이상 대체가 필요했던 각 노드 조각에서 첫 번째 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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는 COPY 명령을 실행하면서 Amazon S3에서 데이터를 전송하는 동안 발생한 오류 정보를 확인하는 데 사용됩니다.
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/ko_kr/redshift/latest/dg/r_STL_S3CLIENT_ERROR.html)
## 사용 노트
"Connection timed out" 오류가 다수 발생한 경우에는 네트워킹 문제를 의심해볼 수 있습니다. Enhanced VPC Routing 기능을 사용하는 경우에는 클러스터의 VPC와 데이터 리소스 사이의 네트워크 경로가 유효한지 확인하세요. 자세한 내용은 [Amazon Redshift Enhanced VPC Routing](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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_SCAN.html)
## 스캔 유형
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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` 값의 차이는 쿼리에서 필터링되는 행의 수입니다. 사용자 필터로 인해 다수의 행이 무시되는 경우에는 sort 열 선택을 살펴보고, 그렇지 않고 정렬되지 않은 영역이 너무 커서 다수의 행이 무시되는 경우에는 VACUUM을 실행하세요.
## 샘플 쿼리
다음은 테이블에 삭제만 되고 아직 정리되지 않은 행(고스트 행)이 있기 때문에 `rows_pre_filter` 값이 `rows_pre_user_filter` 값보다 큰 것을 나타내는 예입니다.
```
SELECT query, slice, segment,step,rows, rows_pre_filter, rows_pre_user_filter
from stl_scan where query = pg_last_query_id();
query | slice | segment | step | rows | rows_pre_filter | rows_pre_user_filter
-------+--------+---------+------+-------+-----------------+----------------------
42915 | 0 | 0 | 0 | 43159 | 86318 | 43159
42915 | 0 | 1 | 0 | 1 | 0 | 0
42915 | 1 | 0 | 0 | 43091 | 86182 | 43091
42915 | 1 | 1 | 0 | 1 | 0 | 0
42915 | 2 | 0 | 0 | 42778 | 85556 | 42778
42915 | 2 | 1 | 0 | 1 | 0 | 0
42915 | 3 | 0 | 0 | 43428 | 86856 | 43428
42915 | 3 | 1 | 0 | 1 | 0 | 0
42915 | 10000 | 2 | 0 | 4 | 0 | 0
(9 rows)
```
# STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS
스키마 할당량이 초과되면 발생, 타임스탬프, 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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)
```
테이블 ID는 직렬성 위반 오류 메시지(error 1023)의 DETAIL 영역에서 가져올 수 있습니다.
# 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/ko_kr/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/ko_kr/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 문에서 생성되는 각 파일마다 행 1개를 기록합니다. 예를 들어 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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STL_USERLOG.html)
## 샘플 쿼리
다음은 사용자 작업 4개를 실행한 후 STL\$1USERLOG 뷰에 대한 쿼리를 실행하는 예입니다.
```
create user userlog1 password 'Userlog1';
alter user userlog1 createdb createuser;
alter user userlog1 rename to userlog2;
drop user userlog2;
select userid, username, oldusername, action, usecreatedb, usesuper from stl_userlog order by recordtime desc;
```
```
userid | username | oldusername | action | usecreatedb | usesuper
--------+-----------+-------------+---------+-------------+----------
108 | userlog2 | | drop | 1 | 1
108 | userlog2 | userlog1 | rename | 1 | 1
108 | userlog1 | | alter | 1 | 1
108 | userlog1 | | create | 0 | 0
(4 rows)
```
# STL\$1UTILITYTEXT
SELECT를 제외하고 데이터베이스에서 실행된 SQL 명령 텍스트를 수집합니다.
STL\$1UTILITYTEXT 뷰에 대한 쿼리를 실행하여 다음과 같이 시스템에서 실행된 SQL 문의 하위 집합을 수집합니다.
+ ABORT, BEGIN, COMMIT, END, ROLLBACK
+ ANALYZE
+ CALL
+ CANCEL
+ COMMENT
+ CREATE, ALTER, DROP DATABASE
+ CREATE, ALTER, DROP USER
+ EXPLAIN
+ GRANT, REVOKE
+ LOCK
+ reset
+ SET
+ SHOW
+ TRUNCATE
[STL\$1DDLTEXT](r_STL_DDLTEXT.md)[STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) 및 도 참조하세요.[SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md)
STARTTIME 열과 ENDTIME 열은 일정 시간 동안 기록된 문을 확인하는 데 사용됩니다. 긴 SQL 텍스트 블록은 200개 문자의 길이로 구분되며, SEQUENCE 열에서 단일 문에 속하는 텍스트 조각을 식별할 수 있습니다.
STL\$1UTILITYTEXT 시스템 테이블은 구체화된 뷰의 MANUAL 및 AUTO REFRESH 작업을 모두 지원합니다. 구체화된 뷰에서 AUTO REFRESH를 식별하려면 `label` 열을 찾습니다. 모든 AUTO REFRESH 쿼리에는 값이 `maintenance`인 레이블이 있습니다.
STL\$1UTILITYTEXT는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_STL_UTILITYTEXT.html)
## 샘플 쿼리
다음은 2012년 1월 26일에 실행된 "utility" 명령 텍스트를 반환하는 쿼리입니다. 여기에서는 SET 명령 몇 개와 SHOW ALL 명령 1개가 실행되었습니다.
```
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` 열의 1개 이상의 부분에서 SQL을 생성합니다. 재구성된 SQL을 실행하기 전에 모든 (`\n`) 특수 문자를 줄 바꿈으로 바꿉니다. 다음 SELECT 문의 결과는 `query_statement` 필드에서 재구성된 SQL의 행입니다.
```
SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement
FROM stl_utilitytext GROUP BY xid order by xid;
```
예를 들어 다음 쿼리는 query\$1group을 제로 문자열로 설정합니다. 쿼리 자체는 200자 이상이며 STL\$1UTILITYTEXT에 여러 부분으로 저장됩니다.
```
set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000';
```
이 예제에서 이 쿼리는 STL\$1UTILITYTEXT의 `text` 열에 많은 두 부분(행)으로 저장됩니다.
```
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/ko_kr/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개였고, 이 행들은 1MB 블록 28개에 저장되어 있었습니다. Amazon Redshift는 vacuum 작업을 통해 984개 또는 17개 블록의 디스크 공간을 회수할 수 있다고 추정했습니다.
완료 상태 행의 경우 ROWS 열에는 966 값이 표시되고, BLOCKS 열 값은 28에서 11로 감소합니다. vacuum은 예상 디스크 공간을 재확보했으며, vacuum 작업이 완료된 후 재확보 가능한 행이나 공간이 남지 않았습니다.
정렬 단계(트랜잭션 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STV_ACTIVE_CURSORS.html)
# STV\$1BLOCKLIST
STV\$1BLOCKLIST에는 데이터베이스에서 각 조각, 테이블 또는 열마다 사용하는 1MB 디스크 블록의 수가 저장됩니다.
아래 예에 나온 것처럼 STV\$1BLOCKLIST에 집계 쿼리를 사용하여 데이터베이스, 테이블, 조각 또는 열마다 할당되는 1MB 디스크 블록의 수를 확인합니다. 또한 [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/ko_kr/redshift/latest/dg/r_STV_BLOCKLIST.html)
## 샘플 쿼리
STV\$1BLOCKLIST는 할당된 디스크 블록당 1개의 행이 포함되므로 모든 행을 선택하는 쿼리는 매우 많은 수의 행을 반환할 수 있습니다. STV\$1BLOCKLIST에는 집계 쿼리만 사용하는 것이 좋습니다.
[SVV\$1DISKUSAGE](r_SVV_DISKUSAGE.md) 뷰는 유사한 정보를 더욱 사용자 친화적인 형식으로 제공하지만 다음 예는 STV\$1BLOCKLIST 테이블에 대한 한 가지 용도를 설명한 것입니다.
VENUE 테이블의 각 열에서 사용하는 1MB 블록 수를 확인하려면 다음과 같이 쿼리를 입력합니다.
```
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 테이블의 각 열에 할당되는 1MB 블록의 수를 반환합니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STV_EXEC_STATE.html)
## 샘플 쿼리
STV\$1EXEC\$1STATE에 대해 직접 쿼리를 실행하기보다는 SVL\$1QUERY\$1SUMMARY 또는 SVV\$1QUERY\$1STATE에 대해 쿼리를 실행하여 더욱 사용자 친화적인 형식으로 STV\$1EXEC\$1STATE의 정보를 가져오는 방법이 권장됩니다. 자세한 내용은 [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md) 또는 [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md) 테이블 설명서를 참조하십시오.
# 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를 사용하는 경우 다음 사항에 유의하세요.
+ 장기간 실행 중인 미결 트랜잭션은 일반적으로 부하를 증가시킵니다. 이러한 미결 트랜잭션으로 인해 다른 쿼리의 실행 시간이 길어질 수 있습니다.
+ 장기 실행되는 복사 및 ETL 작업은 많은 컴퓨팅 리소스를 사용하는 경우 클러스터에서 실행 중인 다른 쿼리에 영향을 미칠 수 있습니다. 대부분의 경우 이러한 장기 실행 작업을 사용량이 적은 시간으로 옮기면 보고 또는 분석 워크로드의 성능이 향상됩니다.
+ STV\$1INFLIGHT와 관련된 정보를 제공하는 뷰가 있습니다. 여기에는 SQL 명령에 대한 쿼리 텍스트를 캡처하는 STL\$1QUERYTEXT와 STV\$1INFLIGHT를 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)에 조인하는 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.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/ko_kr/redshift/latest/dg/r_STV_INFLIGHT.html)
## 샘플 쿼리
현재 데이터베이스에서 활성화되어 실행 중인 모든 쿼리를 확인하려면 다음과 같이 쿼리를 입력합니다.
```
select * from stv_inflight;
```
아래 샘플 출력은 STV\$1INFLIGHT 쿼리 자체와 이름이 `avgwait.sql`인 스크립트에서 실행된 쿼리를 포함하여 현재 2개의 쿼리가 실행 중인 것을 나타냅니다.
```
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 문의 상태에 대한 정보를 확인할 때 사용됩니다.
100만 개의 레코드가 로드될 때마다 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/ko_kr/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는 사용자 2명이 동시에 똑같은 테이블을 업데이트하지 못하도록 테이블을 잠급니다. 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/ko_kr/redshift/latest/dg/r_STV_LOCKS.html)
## 샘플 쿼리
현재 트랜잭션에서 일어나는 모든 잠금을 보려면 다음과 같이 명령을 입력합니다.
```
select table_id, last_update, lock_owner, lock_owner_pid from stv_locks;
```
위 쿼리를 실행하면 다음과 같이 현재 활성화된 잠금 3개를 표시하는 샘플 출력을 반환합니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_STV_NODE_STORAGE_CAPACITY.html)
## 샘플 쿼리
**참고**
다음 예의 결과는 클러스터의 노드 사양에 따라 다릅니다. SQL SELECT에 열 `capacity`를 추가하여 클러스터의 용량을 검색합니다.
다음 쿼리는 사용된 공간과 총 용량을 1MB 디스크 블록으로 반환합니다. 이 예는 2노드 dc2.8xlarge 클러스터에서 실행되었습니다.
```
select node, used from stv_node_storage_capacity order by node;
```
위 쿼리는 다음과 같은 샘플 출력을 반환합니다.
```
node | used
------+-------
0 | 30597
1 | 27089
```
다음 쿼리는 사용된 공간과 총 용량을 1MB 디스크 블록으로 반환합니다. 이 예는 2노드 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에는 논리적 디스크 볼륨을 기준으로 노드 1개당 행 1개가 포함됩니다.
STV\$1PARTITIONS는 슈퍼 사용자에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_STV_PARTITIONS.html)
## 샘플 쿼리
아래 쿼리는 1MB 디스크 블록에서 사용된 디스크 공간과 용량을 반환한 후 디스크 사용량을 원시 디스크 공간 비율로 계산합니다. 원시 디스크 공간에는 Amazon Redshift가 내부 사용 목적으로 예약하는 공간도 포함되므로 사용자가 사용할 수 있는 디스크 공간 크기인 공칭 디스크 용량보다 더 커야 합니다. Amazon Redshift 관리 콘솔의 [**성능(Performance)**] 탭에 있는 [**사용된 디스크 공간의 백분율(Percentage of Disk Space Used)**] 지표는 클러스터에서 사용하는 공칭 디스크 용량의 백분율을 보고합니다. 여기에서 **사용된 디스크 공간의 비율(%)** 지표를 모니터링하면서 클러스터의 공칭 디스크 용량을 넘지 않도록 사용량을 유지하는 것이 좋습니다.
**중요**
클러스터의 공칭 디스크 용량을 초과하지 않는 것이 좋습니다. 특정 환경에서 기술적으로 가능할 수 있지만, 공칭 디스크 용량을 초과하면 클러스터의 내결함성이 감소하고 데이터 손실 위험이 증가합니다.
다음은 노드 1개당 논리적 디스크 파티션이 6개인 2노드 클러스터에서 실행한 예입니다. 각 디스크 사용률이 약 25%를 기록하면서 디스크 공간이 매우 균일하게 사용되고 있습니다.
```
select owner, host, diskno, used, capacity,
(used-tossed)/capacity::numeric *100 as pctused
from stv_partitions order by owner;
owner | host | diskno | used | capacity | pctused
-------+------+--------+--------+----------+---------
0 | 0 | 0 | 236480 | 949954 | 24.9
0 | 0 | 1 | 236420 | 949954 | 24.9
0 | 0 | 2 | 236440 | 949954 | 24.9
0 | 1 | 2 | 235150 | 949954 | 24.8
0 | 1 | 1 | 237100 | 949954 | 25.0
0 | 1 | 0 | 237090 | 949954 | 25.0
1 | 1 | 0 | 236310 | 949954 | 24.9
1 | 1 | 1 | 236300 | 949954 | 24.9
1 | 1 | 2 | 236320 | 949954 | 24.9
1 | 0 | 2 | 237910 | 949954 | 25.0
1 | 0 | 1 | 235640 | 949954 | 24.8
1 | 0 | 0 | 235380 | 949954 | 24.8
(12 rows)
```
# STV\$1QUERY\$1METRICS
사용자 정의 쿼리 대기열(서비스 클래스)에서 실행 중인 활성 쿼리의 지표 정보(처리된 행의 수, CPU 사용량, 입/출력, 디스크 사용량)가 저장됩니다. 완료된 쿼리의 지표를 보려면 [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) 시스템 테이블을 참조하십시오.
쿼리 지표는 1초 간격으로 샘플링됩니다. 결과적으로 동일한 쿼리라고 해도 다르게 실행하면 약간 다른 시간을 반환할 수 있습니다. 또한 1초 이내에 실행되는 쿼리 세그먼트는 기록되지 않을 수도 있습니다.
STV\$1QUERY\$1METRICS은 지표를 쿼리, 세그먼트 및 단계 수준으로 추적 및 집계합니다. 쿼리 세그먼트 및 단계에 대한 자세한 내용은 [쿼리 계획 및 실행 워크플로우](c-query-planning.md) 섹션을 참조하세요. 노드 조각에서 합산되는 지표도 `max_rows`, `cpu_time` 등 매우 많습니다. 노드 조각에 대한 자세한 내용은 [데이터 웨어하우스 시스템 아키텍처](c_high_level_system_architecture.md) 섹션을 참조하세요.
행이 지표를 보고하는 수준을 확인하고 싶으면 다음과 같이 `segment` 열과 `step_type` 열을 살펴보십시오.
+ `segment` 열과 `step_type` 열의 값이 모두 `-1`이면 행이 쿼리 수준에서 지표를 보고합니다.
+ `segment` 열이 `-1`이 아니고, `step_type` 열이 `-1`이면 행이 세그먼트 수준에서 지표를 보고합니다.
+ `segment` 열과 `step_type` 열의 값이 모두 `-1`이 아니면 행이 단계 수준에서 지표를 보고합니다.
STV\$1QUERY\$1METRICS는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_STV_QUERY_METRICS.html)
## 단계 유형
다음 표는 데이터베이스 사용자와 관련된 단계 유형을 나열한 것입니다. 내부 전용 단계 유형은 표에서 제외되었습니다. 단계 유형이 -1이면 단계 수준에서는 지표가 보고되지 않습니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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
```
중첩 루프 조인을 사용하여 반환된 행의 수가 100만 개가 넘는 활성 쿼리를 찾으려면 다음과 같이 쿼리를 실행합니다.
```
select query, rows
from stv_query_metrics
where step_type = 15 and rows > 1000000
order by rows;
query | rows
------+-----------
25775 | 1580225854
```
실행 시간이 60초보다 크고, CPU 시간이 10초 미만인 활성 쿼리를 찾으려면 다음과 같이 쿼리를 실행하세요.
```
select query, run_time/1000000 as run_time_seconds
from stv_query_metrics
where segment = -1 and run_time > 60000000 and cpu_time < 10000000;
query | run_time_seconds
------+-----------------
25775 | 114
```
# STV\$1RECENTS
STV\$1RECENTS 테이블은 데이터베이스에서 현재 활성 쿼리와 최근에 실행한 쿼리에 대한 정보를 확인하는 데 사용됩니다.
STV\$1RECENTS는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
## STV\$1RECENTS를 사용한 문제 해결
STV\$1RECENTS는 쿼리 또는 쿼리 모음이 현재 실행 중인지 또는 완료되었는지 확인하는 데 특히 유용합니다. 또한 쿼리가 실행된 기간도 표시됩니다. 이는 어떤 쿼리가 오래 실행되는지 파악하는 데 유용합니다.
STV\$1RECENTS를 [STV\$1INFLIGHT](r_STV_INFLIGHT.md)와 같은 다른 시스템 보기에 조인하여 실행 중인 쿼리에 대한 추가 메타데이터를 수집할 수 있습니다. (샘플 쿼리 섹션에 이 작업을 수행하는 방법을 보여주는 예가 있습니다.) 또한 이 뷰에서 반환된 레코드를 Amazon Redshift 콘솔의 모니터링 기능과 함께 사용하여 실시간으로 문제 해결을 할 수도 있습니다.
STV\$1RECENTS를 보완하는 시스템 뷰에는 SQL 명령에 대한 쿼리 텍스트를 검색하는 [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md)와 STV\$1INFLIGHT를 STL\$1QUERYTEXT에 조인하는 [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md)가 포함됩니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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에서 활성 사용자 세션에 대한 정보를 확인하는 데 사용됩니다.
세션 이력을 보려면 STV\$1SESSIONS가 아닌 [STL\$1SESSIONS](r_STL_SESSIONS.md) 테이블을 사용합니다.
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/ko_kr/redshift/latest/dg/r_STV_SESSIONS.html)
## 샘플 쿼리
현재 Amazon Redshift에 로그인한 사용자가 더 있는지 빠르게 확인하려면 다음과 같이 쿼리를 입력합니다.
```
select count(*)
from stv_sessions;
```
반환되는 결과가 1보다 크면 다른 사용자 1명 이상이 현재 데이터베이스에 로그인한 것을 의미합니다.
Amazon Redshift의 활성 세션을 모두 확인하려면 다음과 같이 쿼리를 입력합니다.
```
select *
from stv_sessions;
```
다음 결과에는 현재 Amazon Redshift에서 실행 중인 활성 세션 4개가 표시됩니다.
```
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라는 접두사가 붙은 사용자 이름은 해당 사용자가 페더레이션된 Single Sign-On을 사용하여 로그인했음을 나타냅니다. 자세한 내용은 [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/ko_kr/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/ko_kr/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\$1TRANS](r_STV_TBL_TRANS.md)와 다릅니다. STV\$1TBL\$1TRANS 테이블에는 시스템이 쿼리 처리 중 일시적으로 생성하는 데이터베이스 테이블에 대한 정보가 저장됩니다.
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/ko_kr/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/ko_kr/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이 포함되어 있는 것을 알 수 있습니다. 이 테이블에 0바이트가 할당되어 있기 때문에 이러한 쿼리를 메모리에서 실행할 수 있습니다.
# 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVCS_ALERT_EVENT_LOG.html)
## 사용 노트
SVCS\$1ALERT\$1EVENT\$1LOG는 쿼리에서 잠재적 문제를 식별한 후 [쿼리 성능 튜닝](c-optimizing-query-performance.md)의 모범 사례에 따라 데이터베이스 설계를 최적화하여 쿼리를 재작성하는 데 사용할 수 있습니다. SVCS\$1ALERT\$1EVENT\$1LOG는 다음과 같은 알림을 기록합니다.
+ **통계 누락**
통계가 누락된 경우에는 데이터 로드 또는 중요한 업데이트에 이어 ANALYZE를 실행한 다음 COPY 작업에 STATUPDATE를 사용하세요. 자세한 내용은 [Amazon Redshift 쿼리 설계 모범 사례](c_designing-queries-best-practices.md) 섹션을 참조하세요.
+ **중첩 루프**
중첩 루프는 일반적으로 데카르트 곱입니다. 이때는 쿼리를 평가하여 참여하는 테이블이 모두 효율적으로 조인되었는지 확인하세요.
+ **선택의 폭이 제한적인 필터**
반환되는 행과 스캔되는 행의 비율은 0.05미만입니다. 스캔되는 행은 `rows_pre_user_filter `값이고, 반환되는 행은 [STL\$1SCAN](r_STL_SCAN.md) 시스템 테이블의 rows 값입니다. 이 알림은 쿼리가 결과 집합을 확인하기 위해 비정상적으로 많은 수의 행을 스캔하고 있다는 것을 의미합니다. 이러한 문제는 정렬 키가 누락되었거나 잘못되었을 때 발생할 수 있습니다. 자세한 내용은 [정렬 키](t_Sorting_data.md) 섹션을 참조하세요.
+ **지나치게 많은 고스트 행 **
스캔 작업이 정리가 아닌 삭제된 것으로 표시되었거나, 혹은 커밋되지 않고 삽입된 비교적 다수의 행을 건너뛰었습니다. 자세한 내용은 [테이블 Vacuum](t_Reclaiming_storage_space202.md) 섹션을 참조하세요.
+ **다수의 행 분산 **
100만 개가 넘는 행이 해시 조인 또는 집계를 위해 재분산되었습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
+ **다수의 행 브로드캐스팅 **
100만 개가 넘는 행이 해시 조인을 위해 브로드캐스팅되었습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
+ **직렬 실행 **
쿼리 계획에서 DS\$1DIST\$1ALL\$1INNER 재분산 스타일이 지정되면서 내부 테이블 전체가 단일 조각으로 재분산되었기 때문에 직렬 실행을 피할 수 없습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
## 샘플 쿼리
다음은 4개 쿼리의 알림 이벤트를 나타낸 쿼리입니다.
```
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/ko_kr/redshift/latest/dg/r_SVCS_COMPILE.html)
## 샘플 쿼리
이 예에서는 쿼리 35878과 35879가 동일한 SQL 문을 실행했습니다. 쿼리 35878의 컴파일 열은 4개의 쿼리 세그먼트에 대해 `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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVCS_PLAN_INFO.html)
## 샘플 쿼리
다음은 단순한 SELECT 쿼리에서 EXPLAIN 명령을 사용하여 반환되는 쿼리 계획과 SVCS\$1PLAN\$1INFO 테이블에 대한 쿼리를 실행하여 반환되는 쿼리 계획을 비교하는 예입니다.
```
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 명령이 실행하는 쿼리의 정보는 포함되지 않습니다. DDL 및 유틸리티 명령을 포함하여 Amazon Redshift에 의해 완료되는 모든 문의 전체 목록과 정보를 보려면 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/ko_kr/redshift/latest/dg/r_SVCS_QUERY_SUMMARY.html)
## 샘플 쿼리
**쿼리 단계의 처리 정보 확인**
다음 쿼리는 쿼리 87의 각 단계에 대한 기본적 처리 정보를 보여 줍니다.
```
select query, stm, seg, step, rows, bytes
from svcs_query_summary
where query = 87
order by query, seg, step;
```
이 쿼리는 다음 샘플 출력에서 보듯 쿼리 87에 대한 처리 정보를 검색합니다.
```
query | stm | seg | step | rows | bytes
-------+-----+-----+------+--------+---------
87 | 0 | 0 | 0 | 90 | 1890
87 | 0 | 0 | 2 | 90 | 360
87 | 0 | 1 | 0 | 90 | 360
87 | 0 | 1 | 2 | 90 | 1440
87 | 1 | 2 | 0 | 210494 | 4209880
87 | 1 | 2 | 3 | 89500 | 0
87 | 1 | 2 | 6 | 4 | 96
87 | 2 | 3 | 0 | 4 | 96
87 | 2 | 3 | 1 | 4 | 96
87 | 2 | 4 | 0 | 4 | 96
87 | 2 | 4 | 1 | 1 | 24
87 | 3 | 5 | 0 | 1 | 24
87 | 3 | 5 | 4 | 0 | 0
(13 rows)
```
**쿼리 단계가 디스크에 분산되었는지 여부 확인**
다음 쿼리는 쿼리 ID 1025(쿼리의 쿼리 ID를 얻는 방법을 확인하려면 [SVL\$1QLOG](r_SVL_QLOG.md) 뷰를 참조)인 쿼리의 단계가 디스크로 분산되었는지 또는 쿼리가 전적으로 메모리에서 실행되었는지 여부를 보여 줍니다.
```
select query, step, rows, workmem, label, is_diskbased
from svcs_query_summary
where query = 1025
order by workmem desc;
```
위 쿼리는 다음과 같은 샘플 출력을 반환합니다.
```
query| step| rows | workmem | label | is_diskbased
-----+-----+--------+-----------+---------------+--------------
1025 | 0 |16000000| 141557760 |scan tbl=9 | f
1025 | 2 |16000000| 135266304 |hash tbl=142 | t
1025 | 0 |16000000| 128974848 |scan tbl=116536| f
1025 | 2 |16000000| 122683392 |dist | f
(4 rows)
```
IS\$1DISKBASED의 값을 스캔하면 어떤 쿼리 단계가 디스크로 갔는지 알 수 있습니다. 쿼리 1025의 경우, 해시 단계가 디스크에서 실행되었습니다. 디스크에서 실행될 수 있는 단계에는 hash, aggr, sort 단계가 포함됩니다. 디스크 기반 쿼리 단계만 보려면 위의 예에서 **and is\$1diskbased = 't'** 절을 SQL 문에 추가합니다.
# SVCS\$1S3LIST
세그먼트 수준에서 Amazon Redshift Spectrum 쿼리에 대한 세부 정보를 가져오려면 SVCS\$1S3LIST 뷰를 사용합니다. 한 개의 세그먼트로 한 개의 외부 테이블 스캔을 수행할 수 있습니다. 이 뷰는 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/ko_kr/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
세그먼트 수준에서 Redshift Spectrum 쿼리에 대한 문제 해결 세부 정보를 가져오려면 SVCS\$1S3LOG 뷰를 사용합니다. 한 개의 세그먼트로 한 개의 외부 테이블 스캔을 수행할 수 있습니다. 이 뷰는 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/ko_kr/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
세그먼트 수준에서 Redshift Spectrum 쿼리 파티션 처리에 대한 요약을 가져오려면 SVCS\$1S3PARTITION\$1SUMMARY 뷰를 사용합니다. 한 개의 세그먼트로 한 개의 외부 테이블 스캔을 수행할 수 있습니다.
**참고**
접두사 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/ko_kr/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
시스템에서 실행된 모든 Redshift Spectrum 쿼리(S3 쿼리)의 요약을 가져오려면 SVCS\$1S3QUERY\$1SUMMARY 뷰를 사용합니다. 한 개의 세그먼트로 한 개의 외부 테이블 스캔을 수행할 수 있습니다.
**참고**
접두사 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/ko_kr/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/ko_kr/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 문에서 생성되는 각 파일마다 행 1개를 기록합니다. 예를 들어, 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/ko_kr/redshift/latest/dg/r_SVCS_UNLOAD_LOG.html)
## 샘플 쿼리
UNLOAD 명령으로 Amazon S3에 작성된 파일 목록을 가져오려면 UNLOAD 작업을 마친 후 Amazon S3 목록 작업을 호출하면 됩니다. 하지만 Amazon S3 목록 작업은 최종 일관성(eventually consistent)을 따르기 때문에 호출을 얼마나 빠르게 실행하는가에 따라 목록이 불안정할 수 있습니다. 믿을 수 있는 완전한 목록을 바로 가져오려면 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 뷰는 자세한 정보를 위해 STL 테이블 및 로그에 대한 참조를 포함하는 Amazon Redshift의 시스템 뷰입니다.
이러한 보기는 이들 테이블에서 찾을 수 있는 일반적으로 쿼리되는 데이터에 대한 보다 빠르고 쉬운 액세스를 제공합니다.
**참고**
SVL\$1QUERY\$1SUMMARY 보기에는 Amazon Redshift가 실행하는 쿼리에 대한 정보만 포함되며 다른 유틸리티 및 DDL 명령이 실행하는 쿼리의 정보는 포함되지 않습니다. DDL 및 유틸리티 명령을 포함하여 Amazon Redshift에 의해 실행되는 모든 문의 완전한 목록과 정보를 보려면 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/ko_kr/redshift/latest/dg/r_SVL_AUTO_WORKER_ACTION.html)
`status` 열 값의 몇 가지 예는 다음과 같습니다.
+ Skipped:Table not found.
+ Skipped:Recommendation is empty.
+ Skipped:Apply sortkey recommendation is disabled.
+ Skipped:Retry exceeds the maximum limit for a table.
+ Skipped:Table column has changed.
+ Abort:This table is not AUTO.
+ Abort:This table has been recently converted.
+ Abort:This table exceeds table size threshold.
+ Abort:This table is already the recommended style.
+ Checkpoint: progress *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/ko_kr/redshift/latest/dg/r_SVL_COMPILE.html)
## 샘플 쿼리
이 예에서는 쿼리 35878과 35879가 동일한 SQL 문을 실행했습니다. 쿼리 35878의 컴파일 열은 4개의 쿼리 세그먼트에 대해 `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
생산자 클러스터와 소비자 클러스터 모두에서 datashare의 변경 내용을 추적하기 위한 통합 뷰를 기록합니다.
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/ko_kr/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/ko_kr/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
datashare의 활동과 사용량을 기록합니다. 이 뷰는 소비자 클러스터에만 관련이 있습니다.
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/ko_kr/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
datashare의 활동과 사용량을 기록합니다. 이 뷰는 생산자 클러스터에만 관련이 있습니다.
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/ko_kr/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/ko_kr/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
트랜잭션 블록 제한을 위반하는 시스템에서 실행되는 모든 SQL 명령의 전체 레코드를 가져오려면 SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS 뷰를 사용합니다.
Amazon Redshift가 트랜잭션 블록 또는 다중 문 요청 내에서 제한하는 다음 SQL 명령을 실행할 때 위반이 발생합니다.
+ [데이터베이스 생성](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/ko_kr/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/ko_kr/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/ko_kr/redshift/latest/dg/r_SVL_QLOG.html)
## 샘플 쿼리
다음 예는 `userid = 100`인 사용자가 실행한 가장 최근의 데이터베이스 쿼리 5개의 쿼리 ID, 실행 시간, 잘린 쿼리 텍스트를 반환합니다.
```
select query, pid, elapsed, substring from svl_qlog
where userid = 100
order by starttime desc
limit 5;
query | pid | elapsed | substring
--------+-------+----------+-----------------------------------------------
187752 | 18921 | 18465685 | select query, elapsed, substring from svl_...
204168 | 5117 | 59603 | insert into testtable values (100);
187561 | 17046 | 1003052 | select * from pg_table_def where tablename...
187549 | 17046 | 1108584 | select * from STV_WLM_SERVICE_CLASS_CONFIG
187468 | 17046 | 5670661 | select * from pg_table_def where schemaname...
(5 rows)
```
다음 예는 취소된(**aborted=1**) 쿼리의 SQL 스크립트 이름(LABEL 열) 및 경과 시간을 반환합니다.
```
select query, elapsed, trim(label) querylabel
from svl_qlog where aborted=1;
query | elapsed | querylabel
-------+----------+-------------------------
16 | 6935292 | alltickittablesjoin.sql
(1 row)
```
# SVL\$1QUERY\$1METRICS
SVL\$1QUERY\$1METRICS 뷰는 완료된 쿼리의 지표를 보여 줍니다. 이 보기는 [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) 시스템 테이블에서 파생됩니다. 쿼리 모니터링 규칙을 정의하기 위한 임계값을 결정하는 데 이 보기의 값들을 사용하세요. 자세한 내용은 [WLM 쿼리 모니터링 규칙](cm-c-wlm-query-monitoring-rules.md) 섹션을 참조하세요.
SVL\$1QUERY\$1METRICS는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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 뷰를 사용하여 쿼리 실행에 대한 일반 정보를 찾습니다.
SVV\$1QUERY\$1SUMMARY 뷰에는 SVL\$1QUERY\$1REPORT 뷰의 데이터 하위 집합이 포함됩니다. SVL\$1QUERY\$1SUMMARY의 정보는 모든 노드에서 집계됩니다.
**참고**
SVL\$1QUERY\$1SUMMARY 보기에는 Amazon Redshift가 수행하는 쿼리에 대한 정보만 포함되며 다른 유틸리티 및 DDL 명령이 실행하는 쿼리의 정보는 포함되지 않습니다. DDL 및 유틸리티 명령을 포함하여 Amazon Redshift에 의해 수행되는 모든 문의 전체 목록과 정보를 보려면 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/ko_kr/redshift/latest/dg/r_SVL_QUERY_SUMMARY.html)
## 샘플 쿼리
**쿼리 단계의 처리 정보 확인**
다음 쿼리는 쿼리 87의 각 단계에 대한 기본적 처리 정보를 보여 줍니다.
```
select query, stm, seg, step, rows, bytes
from svl_query_summary
where query = 87
order by query, seg, step;
```
이 쿼리는 다음 샘플 출력에서 보듯 쿼리 87에 대한 처리 정보를 검색합니다.
```
query | stm | seg | step | rows | bytes
-------+-----+-----+------+--------+---------
87 | 0 | 0 | 0 | 90 | 1890
87 | 0 | 0 | 2 | 90 | 360
87 | 0 | 1 | 0 | 90 | 360
87 | 0 | 1 | 2 | 90 | 1440
87 | 1 | 2 | 0 | 210494 | 4209880
87 | 1 | 2 | 3 | 89500 | 0
87 | 1 | 2 | 6 | 4 | 96
87 | 2 | 3 | 0 | 4 | 96
87 | 2 | 3 | 1 | 4 | 96
87 | 2 | 4 | 0 | 4 | 96
87 | 2 | 4 | 1 | 1 | 24
87 | 3 | 5 | 0 | 1 | 24
87 | 3 | 5 | 4 | 0 | 0
(13 rows)
```
**쿼리 단계가 디스크에 분산되었는지 여부 확인**
다음 쿼리는 쿼리 ID 1025(쿼리의 쿼리 ID를 얻는 방법을 확인하려면 [SVL\$1QLOG](r_SVL_QLOG.md) 뷰를 참조)인 쿼리의 단계가 디스크로 분산되었는지 또는 쿼리가 전적으로 메모리에서 실행되었는지 여부를 보여 줍니다.
```
select query, step, rows, workmem, label, is_diskbased
from svl_query_summary
where query = 1025
order by workmem desc;
```
위 쿼리는 다음과 같은 샘플 출력을 반환합니다.
```
query| step| rows | workmem | label | is_diskbased
-----+-----+--------+-----------+---------------+--------------
1025 | 0 |16000000| 141557760 |scan tbl=9 | f
1025 | 2 |16000000| 135266304 |hash tbl=142 | t
1025 | 0 |16000000| 128974848 |scan tbl=116536| f
1025 | 2 |16000000| 122683392 |dist | f
(4 rows)
```
IS\$1DISKBASED의 값을 스캔하면 어떤 쿼리 단계가 디스크로 갔는지 알 수 있습니다. 쿼리 1025의 경우, 해시 단계가 디스크에서 실행되었습니다. 디스크에서 실행될 수 있는 단계에는 hash, aggr, sort 단계가 포함됩니다. 디스크 기반 쿼리 단계만 보려면 위의 예에서 **and is\$1diskbased = 't'** 절을 SQL 문에 추가합니다.
# SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS
RA3 노드로의 클래식 크기 조정 중에 클러스터 내 각 테이블의 마이그레이션 진행 상황을 모니터링하려면 SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS를 사용합니다. 이는 크기 조정 작업 중 데이터 마이그레이션의 과거 처리량을 캡처합니다. 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/ko_kr/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
세그먼트 수준에서 Amazon Redshift Spectrum 쿼리에 대한 세부 정보를 가져오려면 SVL\$1S3LIST 뷰를 사용합니다.
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/ko_kr/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
세그먼트 및 노드 조각 수준에서 Amazon Redshift Spectrum 쿼리에 대한 세부 정보를 가져오려면 SVL\$1S3LOG 뷰를 사용합니다.
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/ko_kr/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
세그먼트 및 노드 조각 수준에서 Amazon Redshift Spectrum 파티션에 대한 세부 정보를 가져오려면 SVL\$1S3PARTITION 뷰를 사용합니다.
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/ko_kr/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
세그먼트 수준에서 Redshift Spectrum 쿼리 파티션 처리에 대한 요약을 가져오려면 SVL\$1S3PARTITION\$1SUMMARY 뷰를 사용합니다.
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/ko_kr/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
세그먼트 및 노드 조각 수준에서 Amazon Redshift Spectrum 쿼리에 대한 세부 정보를 가져오려면 SVL\$1S3QUERY 뷰를 사용합니다.
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/ko_kr/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
시스템에서 실행된 모든 Amazon Redshift Spectrum 쿼리(S3 쿼리)의 요약을 가져오려면 SVL\$1S3QUERY\$1SUMMARY 뷰를 사용합니다. 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/ko_kr/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/ko_kr/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/ko_kr/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\$1SPECT\$1SCAN\$1ERROR을 쿼리하여 Redshift Spectrum 스캔 오류에 대한 정보를 가져올 수 있습니다.
SVL\$1SPECT\$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/ko_kr/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
시스템에서 실행된 모든 SQL 명령의 완전한 레코드를 가져오려면 SVL\$1STATEMENTTEXT 뷰를 사용합니다.
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/ko_kr/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` 열의 1개 이상의 부분에서 SQL을 생성합니다. 재구성된 SQL을 실행하기 전에 모든 (`\n`) 특수 문자를 줄 바꿈으로 바꿉니다. 다음 SELECT 문의 결과는 `query_statement` 필드에서 재구성된 SQL의 행입니다.
```
select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS query_statement
from SVL_STATEMENTTEXT where pid=pg_backend_pid();
```
예를 들어 다음 쿼리는 열 3개를 선택합니다. 쿼리 자체는 200자 이상이며 SVL\$1STATEMENTTEXT에 여러 부분으로 저장됩니다.
```
select
1 AS a0123456789012345678901234567890123456789012345678901234567890,
2 AS b0123456789012345678901234567890123456789012345678901234567890,
3 AS b012345678901234567890123456789012345678901234
FROM stl_querytext;
```
이 예제에서 이 쿼리는 SVL\$1STATEMENTTEXT의 `text` 열에 많은 두 부분(행)으로 저장됩니다.
```
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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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에 로깅 및 경고 메시지를 추가하므로 0으로 나누기 연산은 오류 메시지와 함께 중단되는 대신 경고 메시지를 생성합니다.
```
-- 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/ko_kr/redshift/latest/dg/r_SVL_USER_INFO.html)
## 샘플 쿼리
다음 명령은 SVL\$1USER\$1INFO에서 사용자 정보를 검색합니다.
```
SELECT * FROM SVL_USER_INFO;
```
# SVL\$1VACUUM\$1PERCENTAGE
SVL\$1VACUUM\$1PERCENTAGE 뷰는 vacuum을 수행한 후 테이블에 할당되는 데이터 블록의 백분율을 보고합니다. 이 백분율 숫자는 디스크 공간이 얼마나 회수되었는지 보여 줍니다. vacuum 유틸리티에 대한 자세한 내용은 [VACUUM](r_VACUUM_command.md) 명령을 참조하세요.
SVL\$1VACUUM\$1PERCENTAGE는 슈퍼 사용자에게만 표시됩니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
이 테이블의 데이터 중 일부 또는 전부는 SYS 모니터링 뷰인 [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)에서도 찾아볼 수 있습니다. SYS 모니터링 뷰의 데이터는 사용 및 이해가 더 쉽도록 형식이 지정되어 있습니다. 쿼리에 SYS 모니터링 뷰를 사용하는 것이 좋습니다.
## 테이블 열
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_SVL_VACUUM_PERCENTAGE.html)
## 샘플 쿼리
다음 쿼리는 테이블 100238에서의 특정 작업의 백분율을 표시합니다.
```
select * from svl_vacuum_percentage
where table_id=100238 and xid=2200;
xid | table_id | percentage
-----+----------+------------
1337 | 100238 | 60
(1 row)
```
이 vacuum 작업 후 테이블에는 원본 블록의 60퍼센트가 포함되었습니다.
# 시스템 카탈로그 테이블
**Topics**
+ [PG\$1ATTRIBUTE\$1INFO](r_PG_ATTRIBUTE_INFO.md)
+ [PG\$1CLASS\$1INFO](r_PG_CLASS_INFO.md)
+ [PG\$1DATABASE\$1INFO](r_PG_DATABASE_INFO.md)
+ [PG\$1DEFAULT\$1ACL](r_PG_DEFAULT_ACL.md)
+ [PG\$1EXTERNAL\$1SCHEMA](r_PG_EXTERNAL_SCHEMA.md)
+ [PG\$1LIBRARY](r_PG_LIBRARY.md)
+ [PG\$1PROC\$1INFO](r_PG_PROC_INFO.md)
+ [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md)
+ [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md)
+ [PG\$1USER\$1INFO](pg_user_info.md)
+ [카탈로그 테이블 쿼리](c_join_PG.md)
시스템 카탈로그는 테이블과 열에 대한 정보 등 스키마 메타데이터를 저장합니다. 시스템 카탈로그 테이블에는 PG 접두사가 있습니다.
Amazon Redshift 사용자는 표준 PostgreSQL 카탈로그 테이블에 액세스할 수 있습니다. PostgreSQL 시스템 카탈로그에 대한 자세한 내용은 [PostgreSQL 시스템 테이블](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW)을 참조하세요.
# PG\$1ATTRIBUTE\$1INFO
PG\$1ATTRIBUTE\$1INFO는 PostgreSQL 카탈로그 테이블 PG\$1ATTRIBUTE 및 내부 카탈로그 테이블 PG\$1ATTRIBUTE\$1ACL에 빌드된 Amazon Redshift 시스템 뷰입니다. PG\$1ATTRIBUTE\$1INFO에는 열 액세스 제어 목록(있는 경우)을 포함하여 테이블 또는 뷰의 열에 대한 세부 정보가 포함됩니다.
## 테이블 열
PG\$1ATTRIBUTE\$1INFO는 PG\$1ATTRIBUTE의 열 외에도 다음 열을 보여줍니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html)
# PG\$1CLASS\$1INFO
PG\$1CLASS\$1INFO는 PostgreSQL 카탈로그 테이블 PG\$1CLASS 및 PG\$1CLASS\$1EXTENDED를 기반으로 작성된 Amazon Redshift 시스템 뷰입니다. PG\$1CLASS\$1INFO에는 테이블 생성 시간 및 현재 분산 스타일에 대한 세부 정보가 포함되어 있습니다. 자세한 내용은 [쿼리 최적화를 위한 데이터 배포](t_Distributing_data.md) 섹션을 참조하세요.
PG\$1CLASS\$1INFO는 모든 사용자에게 표시됩니다. 수퍼유저는 모든 행을 볼 수 있지만 일반 사용자는 자체 데이터만 볼 수 있습니다. 자세한 내용은 [시스템 테이블 및 뷰에 있는 데이터의 가시성](cm_chap_system-tables.md#c_visibility-of-data) 섹션을 참조하세요.
## 테이블 열
PG\$1CLASS\$1INFO는 PG\$1CLASS의 열 외에도 다음 열을 보여줍니다. PG\$1CLASS의 `oid` 열은 PG\$1CLASS\$1INFO 테이블에서 `reloid`라고 합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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 | 0 |
| 1 | 키 |
| 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\$1INFO는 PG\$1DATABASE의 열 외에도 다음 열을 포함합니다. 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/ko_kr/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/ko_kr/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/ko_kr/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/ko_kr/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\$1CLASS\$1INFO는 PG\$1PROC의 열 외에도 다음 열을 보여줍니다. PG\$1PROC의 `oid` 열은 PG\$1PROC\$1INFO 테이블에서 `prooid`라고 합니다.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/ko_kr/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/ko_kr/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/ko_kr/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는 사용자 ID 및 암호 만료 시간과 같은 사용자 정보를 표시하는 Amazon Redshift 시스템 보기입니다.
수퍼유저만 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/ko_kr/redshift/latest/dg/pg_user_info.html)
# 카탈로그 테이블 쿼리
**Topics**
+ [카탈로그 쿼리 예제](c_join_PG_examples.md)
일반적으로 카탈로그 테이블과 뷰(이름이 **PG\$1**로 시작하는 릴레이션)는 Amazon Redshift 테이블과 뷰로 조인할 수 있습니다.
카탈로그 테이블은 Amazon Redshift가 지원하지 않는 데이터 형식을 다수 사용합니다. 다음은 쿼리가 카탈로그 테이블을 Amazon Redshift 테이블로 조인할 때 지원되는 데이터 형식입니다.
+ bool
+ "char"
+ "char"
+ "char"
+ "char"
+ "char"
+ 이름
+ oid
+ 텍스트
+ varchar
조인 쿼리를 작성하면서 지원되지 않는 데이터 형식이 포함된 열을 명시적으로, 또는 묵시적으로 참조하는 경우에는 쿼리가 오류를 반환합니다. PG\$1SETTINGS 및 PG\$1LOCKS 테이블에서 사용하는 함수를 제외하고 일부 카탈로그 테이블에서 사용되는 SQL 함수 역시 지원되지 않습니다.
예를 들어 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은 컴퓨팅 노드에서 실행됩니다.
CATALOG 테이블(PG\$1TABLE\$1DEF처럼 PG 접두사가 첨부된 테이블)만 참조하거나 어떤 테이블도 참조하지 않는 쿼리는 리더 노드에서만 실행됩니다.
컴퓨팅 노드 함수를 사용하는 쿼리에서 사용자 정의 테이블이나 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)
```