O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de blog ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Visualizações STL de registro em log
As visualizações do sistema STL são geradas a partir dos arquivos de log do Amazon Redshift para fornecer um histórico do sistema.
Esses arquivos residem em cada nó no cluster do data warehouse. As visualizações STL pegam as informações dos logs e as formatam em visualizações utilizáveis para administradores de sistema.
**Retenção de log**: as visualizações do sistema STL retêm sete dias do histórico de log. A retenção de log é garantida para todos os tamanhos e tipos de nós de cluster e não é afetada por mudanças na workload do cluster. A retenção de log também não é afetada pelo status do cluster, como quando o cluster está pausado. Você tem menos de sete dias de histórico de log somente no caso em que o cluster é novo. Não é necessário realizar nenhuma ação para reter os logs, mas será preciso copiar periodicamente os dados de log para outras tabelas ou descarregá-los no Amazon S3 para reter aqueles com mais de sete dias de existência.
**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
Analisa as etapas de execução agregadas para consultas. Essas etapas ocorrem durante a execução de funções agregadas e de cláusulas GROUP BY.
STL\$1AGGR permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1AGGR contém apenas consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_AGGR.html)
## Consultas de exemplo
Retorna informações sobre as etapas de execução agregadas para SLICE 1 e 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
Registra um alerta quando o otimizador de consultas identifica as condições que podem indicar problemas de performance. Use a visualização STL\$1ALERT\$1EVENT\$1LOG para identificar oportunidades para melhorar a performance da consulta.
Uma consulta consiste em vários segmentos e cada segmento consiste em uma ou mais etapas. Para obter mais informações, consulte [Processamento de consulta](c-query-processing.md).
STL\$1ALERT\$1EVENT\$1LOG é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1ALERT\$1EVENT\$1LOG contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_ALERT_EVENT_LOG.html)
## Observações de uso
Você pode usar o STL\$1ALERT\$1EVENT\$1LOG para identificar problemas potenciais nas consultas, depois siga as práticas recomendadas em [Ajustar o desempenho da consulta](c-optimizing-query-performance.md) para otimizar o design do banco de dados e reescrever as consultas. A tabela STL\$1ALERT\$1EVENT\$1LOG registra os seguintes alertas:
+ **Ausência de estatísticas**
Não há estatísticas. Execute o ANALYZE depois de carregar dados ou de atualizações significativas e use o STATUPDATE com as operações COPY. Para obter mais informações, consulte [Práticas recomendadas do Amazon Redshift para criar consultas](c_designing-queries-best-practices.md).
+ **Loop aninhado **
Um loop aninhado é geralmente um produto cartesiano. Avalie sua consulta para assegurar que todas as tabelas que participam das operações estão sendo unidas de forma eficiente.
+ **Filtro muito seletivo**
A taxa de linhas retornadas em relação às linhas pesquisadas na varredura é menor do que 0.05. Linhas verificadas refere-se ao valor de `rows_pre_user_filter` e linhas retornadas refere-se ao valor das linhas na visualização do sistema [STL\$1SCAN](r_STL_SCAN.md). Indica que a consulta está fazendo a varredura em um número excepcionalmente grande de linhas para determinar o conjunto de resultados. Isso pode ser causado pela falta ou por erros de chaves de classificação. Para obter mais informações, consulte [Chaves de classificação](t_Sorting_data.md).
+ **Excesso de linhas fantasma **
Uma varredura ignorou um número relativamente grande de linhas que estão marcadas como excluídas, mas não como limpadas, ou de linhas que foram inseridas, mas não confirmadas. Para obter mais informações, consulte [Vacuum de tabelas](t_Reclaiming_storage_space202.md).
+ **Grande distribuição **
Mais de 1.000.000 de linhas foram redistribuídas para uma junção hash ou agregação. Para obter mais informações, consulte [Distribuição de dados para otimização de consultas](t_Distributing_data.md).
+ **Grande transmissão **
Mais de 1.000.000 de linhas foram transmitidas para uma junção hash. Para obter mais informações, consulte [Distribuição de dados para otimização de consultas](t_Distributing_data.md).
+ **Execução em série **
Um estilo de redistribuição DS\$1DIST\$1ALL\$1INNER foi indicado no plano de consulta, o que força uma execução em série, pois toda a tabela interna foi redistribuída para um único nó. Para obter mais informações, consulte [Distribuição de dados para otimização de consultas](t_Distributing_data.md).
## Consultas de exemplo
As consultas a seguir mostram eventos de alerta para quatro consultas.
```
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
Registra os detalhes das operações [ANALYZE](r_ANALYZE.md).
STL\$1ANALYZE só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_ANALYZE.html)
## Consultas de exemplo
O exemplo a seguir une a STV\$1TBL\$1PERM para mostrar o nome da tabela e os detalhes de execução.
```
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
Registra os detalhes das operações de análise de compactação durante os comandos COPY ou ANALYZE COMPRESSION.
STL\$1ANALYZE\$1COMPRESSION permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_ANALYZE_COMPRESSION.html)
## Consultas de exemplo
O exemplo a seguir inspeciona os detalhes da análise de compactação na tabela `lineitem` pelo último comando COPY executado na mesma sessão.
```
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
Registra informações sobre a atividade de rede durante a execução das etapas de uma consulta que transmite dados. O tráfego de rede é capturado pelos números de linhas, bytes e pacotes que são enviados pela rede durante uma determinada etapa em uma determinada fatia. A duração da etapa é a diferença entre os horários de início e término registrados.
Para identificar as etapas de transmissão em uma consulta, procure pelos rótulos bcast na exibição SVL\$1QUERY\$1SUMMARY ou execute o comando EXPLAIN e, em seguida, procure pelos atributos da etapa que incluem o bcast.
STL\$1BCAST permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1BCAST contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_BCAST.html)
### Consultas de exemplo
O exemplo a seguir retorna as informações transmitidas pelas consultas com um ou mais pacotes e onde a diferença entre o início e o término da consulta seja de um segundo ou mais.
```
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
Fornece métricas relativas à performance da operação de confirmação, incluindo informações sobre o tempo dos vários estágios de confirmação e o número de blocos confirmados. Consulte a STL\$1COMMIT\$1STATS para determinar que parte de uma transação foi gasta na operação de confirmação e o quanto as filas estão sendo utilizadas.
STL\$1COMMIT\$1STATS é visível somente para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_COMMIT_STATS.html)
## Consulta de exemplo
```
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
Registra em log as tentativas de autenticação e as conexões e desconexões.
STL\$1CONNECTION\$1LOG só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_CONNECTION_LOG.html)
## Consultas de exemplo
Para visualizar os detalhes das conexões abertas, execute a consulta a seguir.
```
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)
```
O exemplo a seguir reflete uma tentativa falha de autenticação e uma operação de conexão e desconexão bem-sucedida.
```
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)
```
O exemplo a seguir mostra a versão do driver ODBC, o sistema operacional na máquina cliente e o plug-in usado para se conectar ao cluster do Amazon Redshift. Neste exemplo, o plugin usado é para autenticação de driver ODBC padrão usando um nome de login e senha.
```
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
```
O exemplo a seguir mostra a versão do sistema operacional na máquina cliente, a versão do driver e a versão do protocolo.
```
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
Captura as seguintes instruções de DDL que foram executadas no sistema.
Essas instruções de DDL incluem as seguintes consultas e objetos:
+ CREATE SCHEMA, TABLE, VIEW
+ DROP SCHEMA, TABLE, VIEW
+ ALTER SCHEMA, TABLE
Consulte também [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) e [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md). Essas exibições fornecem uma linha do tempo dos comandos de SQL que são executados no sistema; esse histórico é útil para fins de solução de problemas e para criar uma trilha de auditoria de todas as atividades do sistema.
Use as colunas STARTTIME e ENDTIME para saber quais instruções foram registradas em um determinado período. Os blocos longos de texto SQL são quebrados em linhas de 200 caracteres; a coluna SEQUENCE identifica os fragmentos de texto que pertencem a uma única instrução.
STL\$1DDLTEXT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_DDLTEXT.html)
## Consultas de exemplo
A consulta a seguir retorna registros que incluem instruções de DDL executadas anteriormente.
```
select xid, starttime, sequence, substring(text,1,40) as text
from stl_ddltext order by xid desc, sequence;
```
Esta é uma saída de exemplo que mostra quatro instruções CREATE TABLE. As instruções de DDL aparecem na coluna `text`, que é truncada para legibilidade.
```
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)
```
### Reconstrução de SQL armazenado
O SQL a seguir lista as linhas armazenadas na coluna `text` de STL\$1DDLTEXT. As linhas são ordenadas por `xid` e `sequence`. Se o SQL original for mais extenso que várias linhas de 200 caracteres, STL\$1DDLTEXT poderá conter várias linhas por `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');
...
```
Para reconstruir o SQL armazenado na coluna `text` de STL\$1DDLTEXT, execute a instrução SQL a seguir. Ela reúne instruções de DDL de um ou mais segmentos na coluna `text`. Antes de executar o SQL reconstruído, substitua os caracteres especiais (`\n`) por uma nova linha no cliente SQL. Os resultados a seguir da instrução SELECT reúnem três linhas em sequência para reconstruir o SQL, no campo `query_statement`.
```
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
Analisa as etapas de execução de exclusões das consultas.
STL\$1DELETE permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1DELETE contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_DELETE.html)
## Consultas de exemplo
Para criar uma linha na STL\$1DELETE, o exemplo a seguir insere uma linha na tabela EVENT e, em seguida, exclui a linha.
Primeiro, insira uma linha na tabela EVENT e verifique se ela foi inserida.
```
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)
```
Agora, exclua a linha que você adicionou na tabela EVENT e verifique se ela foi excluída.
```
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)
```
Em seguida, execute uma consulta na stl\$1delete para visualizar as etapas da exclusão. Neste exemplo, a consulta retornou mais de 300 linhas e, portanto, a saída abaixo foi reduzida para possibilitar a exibição.
```
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
Registra informações sobre erros registrados quando o disco está cheio.
STL\$1DISK\$1FULL\$1DIAG só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_DISK_FULL_DIAG.html)
## Consultas de exemplo
O exemplo a seguir retorna detalhes sobre os dados armazenados quando há um erro de disco cheio.
```
select * from stl_disk_full_diag
```
O exemplo a seguir converte `currenttime` em um carimbo de data e hora.
```
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
Registra informações sobre a atividade de rede durante a execução das etapas de uma consulta que distribui dados. O tráfego de rede é capturado pelos números de linhas, bytes e pacotes que são enviados pela rede durante uma determinada etapa em uma determinada fatia. A duração da etapa é a diferença entre os horários de início e término registrados.
Para identificar as etapas de distribuição em uma consulta, procure pelos rótulos dist na exibição QUERY\$1SUMMARY ou execute o comando EXPLAIN e, em seguida, procure pelos atributos da etapa que incluem o dist.
STL\$1DIST permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1DIST contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_DIST.html)
## Consultas de exemplo
O exemplo a seguir retorna informações de distribuição para consultas com um ou mais pacotes e duração maior do que zero.
```
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
Registra erros de processamento interno gerados pelo mecanismo de banco de dados do Amazon Redshift. A tabela STL\$1ERROR não registra os erros ou mensagens de SQL. As informações na STL\$1ERROR são úteis para solucionar determinados erros. Um engenheiro de suporte da AWS pode solicitar que você forneça essas informações como parte do processo de solução de problemas.
STL\$1ERROR permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
Para uma lista de códigos de erros que podem ser gerados enquanto os dados são carregados no comando Copiar, consulte [Referência de erros de carregamento](r_Load_Error_Reference.md).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_ERROR.html)
## Consultas de exemplo
O exemplo a seguir recuperar as informações sobre um erro da 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
Exibe o plano EXPLAIN para uma consulta que foi enviada para execução.
STL\$1EXPLAIN permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1EXPLAIN contém apenas as consultas executadas em clusters principais. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1EXPLAIN](SYS_QUERY_EXPLAIN.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_EXPLAIN.html)
## Consultas de exemplo
Considere a seguinte saída de EXPLAIN para uma consulta de junção agregada:
```
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)
```
Se você executar essa consulta e o ID de consulta for 10, use a tabela STL\$1EXPLAIN para visualizar os mesmos tipos de informações que o comando EXPLAIN retorna:
```
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)
```
Considere a seguinte consulta:
```
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
...
```
Se o ID da consulta for 15, a seguinte consulta de visualização do sistema retornará os nós do plano que foram concluídos. Nesse caso, a ordem dos nós é invertida para mostrar a ordem real de execução:
```
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)
```
A consulta a seguir recupera os IDs de consulta de todos os planos de consulta que contêm uma função de janela:
```
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
Retorna os arquivos que o Amazon Redshift leu ao carregar dados usando o comando COPY.
Consultar esta visualização pode ajudar a solucionar erros de carregamento de dados. STL\$1FILE\$1SCAN pode ser particularmente útil para identificar problemas em carregamentos de dados paralelos, porque carregamentos de dados paralelos normalmente carregam muitos arquivos com um único comando COPY.
STL\$1FILE\$1SCAN permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1FILE\$1SCAN contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_FILE_SCAN.html)
## Consultas de exemplo
A consulta a seguir recupera os nomes e tempos de carregamento de todos os arquivos que o Amazon Redshift levou mais de 1.000.000 de microssegundos para ler.
```
select trim(name)as name, loadtime from stl_file_scan
where loadtime > 1000000;
```
Essa consulta retorna os dados de saída de exemplo a seguir.
```
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
Analisa as etapas de execução de hash para as consultas.
STL\$1HASH permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1HASH contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_HASH.html)
## Consultas de exemplo
O exemplo a seguir retorna informações sobre o número de partições que foram usadas em um hash para a consulta 720, e indica que nenhuma das etapas foi executada em disco.
```
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
Analisa as etapas de execução da junção hash para as consultas.
STL\$1HASHJOIN permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1HASHJOIN contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_HASHJOIN.html)
## Consultas de exemplo
O exemplo a seguir retorna o número de partições usadas em uma junção hash para a consulta 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
Analisa as etapas de execução de inserções das consultas.
STL\$1INSERT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1INSERT contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_INSERT.html)
## Consultas de exemplo
O exemplo a seguir retorna as etapas de execução de inserção para a consulta mais recente.
```
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
Analisa as etapas de execução que ocorrem quando uma cláusula LIMIT é usada em uma consulta SELECT.
STL\$1LIMIT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1LIMIT contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_LIMIT.html)
## Consultas de exemplo
Para gerar uma linha na tabela STL\$1LIMIT, este exemplo primeiro executa a consulta a seguir, com a tabela VENUE usando a cláusula 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)
```
Em seguida, execute as seguintes consultas para encontrar o ID de consulta da última consulta que você executou com a tabela VENUE.
```
select max(query)
from stl_query;
```
```
max
--------
127128
(1 row)
```
Opcionalmente, execute a seguinte consulta para verificar se o ID de consulta corresponde à consulta LIMIT que você executou anteriormente.
```
select query, trim(querytxt)
from stl_query
where query=127128;
```
```
query | btrim
--------+------------------------------------------
127128 | select * from venue order by 1 limit 10;
(1 row)
```
Finalmente, execute a seguinte consulta para obter informações sobre a consulta LIMIT da tabela 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
Retorna informações para rastrear ou solucionar problemas com uma carga de dados.
Essa visualização registra o progresso de cada arquivo de dados à medida que é carregado em uma tabela de banco de dados.
STL\$1LOAD\$1COMMITS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1LOAD\$1COMMITS contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_LOAD_COMMITS.html)
## Consultas de exemplo
O exemplo a seguir retorna os detalhes da última operação 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)
```
A consulta a seguir contém as entradas de uma carga recente de tabelas para o banco de dados 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)
```
O fato de um registro ser gravado no arquivo de log para esta visualização do sistema não significa que o carregamento foi confirmado com êxito como parte de sua transação contida. Para verificar as confirmações de carregamento, consulte a visualização STL\$1UTILITYTEXT e procure o registro COMMIT que corresponde a uma transação COPY. Por exemplo, essa consulta une as tabelas STL\$1LOAD\$1COMMITS e STL\$1QUERY com base em uma subconsulta com a tabela STL\$1UTILITYTEXT:
```
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)
```
Os exemplos a seguir destacam os valores de coluna is\$1partial e 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
Exibe os registros de todos os erros de carregamento do Amazon Redshift.
STL\$1LOAD\$1ERRORS contém um histórico de todos os erros de carregamento do Amazon Redshift. Consulte [Referência de erros de carregamento](r_Load_Error_Reference.md) para obter uma lista abrangente de possíveis erros de carregamento e explicações.
Consulte [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md) para obter detalhes adicionais, como a linha de dados exata e coluna onde ocorreu um erro de análise, depois de consultar STL\$1LOAD\$1ERRORS para descobrir informações gerais sobre o erro.
STL\$1LOAD\$1ERRORS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1LOAD\$1ERRORS contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_LOAD_ERRORS.html)
## Consultas de exemplo
A consulta a seguir une as tabelas STL\$1LOAD\$1ERRORS e STL\$1LOADERROR\$1DETAIL para exibir os detalhes dos erros que ocorreram durante a carga mais recente.
```
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
```
O exemplo a seguir usa a tabela STL\$1LOAD\$1ERRORS com a STV\$1TBL\$1PERM para criar uma exibição nova e, em seguida, usa essa exibição para determinar que erros ocorreram durante o carregamento de dados na tabela 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);
```
Em seguida, a consulta abaixo retorna o último erro ocorrido durante o carregamento na tabela 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;
```
A consulta retorna o último erro de carga ocorrido na tabela EVENT. Se não houver erros de carga, a consulta retorna zero linhas. Neste exemplo, a consulta retorna um único erro:
```
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)
```
Nos casos em que o comando COPY divide automaticamente dados de arquivos grandes, descompactados e delimitados por texto para facilitar o paralelismo, as colunas *line\$1number*, *is\$1parcial* e *start\$1offset* exibem as informações relativas às divisões. (O número da linha pode ser desconhecido nos casos em que o número da linha do arquivo original não está disponível.)
```
--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
Exibe um log de erros de análise de dados que ocorreram no uso do comando COPY para carregar tabelas. Para poupar espaço em disco, um máximo 20 erros por fatia de nó é registrado para cada operação de carga.
Um erro de análise ocorre quando o Amazon Redshift não consegue analisar um campo em uma linha de dados ao carregá-lo em uma tabela. Por exemplo, se uma coluna da tabela está esperando um tipo de dados inteiro e o arquivo de dados contém uma string de caracteres alfabéticos no campo, isso causa um erro de análise.
Consulte a tabela STL\$1LOADERROR\$1DETAIL para obter detalhes adicionais, como a linha e a coluna exatas de um erro de análise, depois de consultar a tabela [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) para obter as informações gerais sobre o erro.
A visualização STL\$1LOADERROR\$1DETAIL contém todas as colunas de dados, incluindo e antes da coluna onde ocorreu o erro de análise. Use o campo VALUE para visualizar os valores dos dados que foram analisados nesta coluna, incluindo as colunas que foram analisadas corretamente até o erro ocorrer.
Esta visualização é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1LOADERROR\$1DETAIL contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_LOADERROR_DETAIL.html)
## Consulta de exemplo
A consulta a seguir une as tabelas STL\$1LOAD\$1ERRORS e STL\$1LOADERROR\$1DETAIL para exibir os detalhes de um erro de análise ocorrido durante o carregamento da tabela EVENT, cujo ID de tabela é 100133:
```
select d.query, d.line_number, d.value,
le.raw_line, le.err_reason
from stl_loaderror_detail d, stl_load_errors le
where
d.query = le.query
and tbl = 100133;
```
O exemplo de saída a seguir mostra as colunas carregadas com êxito, incluindo a coluna com o erro. Neste exemplo, duas colunas foram carregadas com êxito antes de ocorrer o erro de análise na terceira coluna, onde uma string de caracteres foi analisada incorretamente para um campo que esperava um número inteiro. Como o campo esperava um inteiro, ele analisou a string "aaa", que é um dado não inicializado, como um caractere nulo e gerou um erro de análise. A saída mostra o valor bruto, o valor analisado e motivo do erro:
```
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)
```
Quando uma consulta une as tabelas STL\$1LOAD\$1ERRORS e STL\$1LOADERROR\$1DETAIL, ela exibe um motivo de erro para cada coluna da linha de dados, o que significa simplesmente que ocorreu um erro nessa linha. A última linha dos resultados é a coluna onde o erro de análise ocorreu.
# STL\$1MERGE
Analisa as etapas de execução de mesclagem para as consultas. Essas etapas ocorrem quando os resultados de operações paralelas (como classificações e junções) são mesclados no processamento subsequente.
STL\$1MERGE permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1MERGE contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_MERGE.html)
## Consultas de exemplo
O exemplo a seguir retorna 10 resultados de execuções de mesclagem.
```
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
Analisa as etapas de execução da junção de mesclagem para as consultas.
STL\$1MERGEJOIN permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1MERGEJOIN contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_MERGEJOIN.html)
## Consultas de exemplo
O exemplo a seguir retorna os resultados da junção de mesclagem para a consulta mais recente.
```
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
A visualização STL\$1MV\$1STATE contém uma linha para cada transição de estado de uma visão materializada.
Para obter mais informações sobre visões materializadas, consulte [Visões materializadas no Amazon Redshift](materialized-view-overview.md).
STL\$1MV\$1STATE é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1MV\$1STATE](SYS_MV_STATE.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_MV_STATE.html)
A tabela a seguir mostra exemplos de combinações de `event_desc` e `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
```
## Consulta de exemplo
Para exibir o log de transições de estado de visualizações materializadas, execute a consulta a seguir.
```
select * from stl_mv_state;
```
Essa consulta retorna os seguintes dados de saída de exemplo:
```
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
Analisa as etapas de execução da junção de loops aninhados para as consultas.
STL\$1NESTLOOP permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1NESTLOOP contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_NESTLOOP.html)
## Consultas de exemplo
Como a consulta a seguir omite a junção da tabela CATEGORY, ela gera um produto cartesiano parcial, o que não é recomendado. Ela está sendo mostrada aqui para ilustrar um loop aninhado.
```
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;
```
A consulta a seguir mostra os resultados da consulta anterior na visualização 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
Analisa as etapas de consulta que analisam strings e as definem como valores binários para o carregamento.
STL\$1PARSE permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1PARSE contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_PARSE.html)
## Consultas de exemplo
O exemplo a seguir retorna todos os resultados das etapas da consulta para a fatia 1 e o segmento 0, onde as strings são analisadas e definidas como valores binários.
```
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
Use a visualização STL\$1PLAN\$1INFO para examinar a saída EXPLAIN de uma consulta em termos de um conjunto de linhas. Essa é uma forma alternativa de ver os planos de consulta.
STL\$1PLAN\$1INFO permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1PLAN\$1INFO contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_PLAN_INFO.html)
## Consultas de exemplo
Os exemplos a seguir comparam os planos de consulta para uma consulta SELECT simples retornada usando o comando EXPLAIN e consultando a visualização 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)
```
Neste exemplo, o PLANNODE 104 refere-se à varredura sequencial da tabela 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
Contém as linhas das etapas de consulta que são usadas para avaliar expressões.
STL\$1PROJECT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1PROJECT contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_PROJECT.html)
## Consultas de exemplo
O exemplo a seguir retorna todas as linhas das etapas de consulta que foram usadas para avaliar expressões para a fatia 0 e o segmento 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
Retorna as informações de execução de uma consulta de banco de dados.
**nota**
As visualizações STL\$1QUERY e STL\$1QUERYTEXT contêm apenas informações sobre consultas, não outro utilitário e comandos DDL. Para obter uma lista e informações sobre todas as instruções executadas pelo Amazon Redshift, também é possível consultar as visualizações STL\$1DDLTEXT e STL\$1UTILITYTEXT. Para obter uma lista completa de todas as instruções executadas pelo Amazon Redshift, é possível consultar a visualização SVL\$1STATEMENTTEXT.
STL\$1QUERY permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
Observe que, quando o comprimento do texto da consulta é superior a 4 mil caracteres, STL\$1QUERY exibe somente dados truncados. Para obter o texto completo da consulta, você pode usar UNION no texto da consulta em todas as linhas.
**nota**
Para verificar se uma transação que contém a consulta executada foi confirmada com êxito, é necessário realizar uma operação de junção entre as tabelas do sistema e a tabela `sys_transaction_history`. Por exemplo:
```
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;
```
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_QUERY.html)
## Consultas de exemplo
A consulta a seguir lista as cinco consultas mais recentes.
```
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)
```
A consulta a seguir retorna o tempo decorrido em ordem descendente para as consultas executadas no dia 15 de fevereiro de 2013.
```
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)
```
A consulta a seguir mostra o tempo da fila e o tempo de execução para consultas. Consultas com `concurrency_scaling_status = 1` executadas em um cluster de escalabilidade da simultaneidade. Todas as outras consultas executadas no cluster principal.
```
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
Contém as informações de métricas, como o número de linhas processadas, utilização da CPU, entrada/saída e utilização do disco, para consultas que concluíram a execução nas filas de consultas definidas pelo usuário (classes de serviço). Para visualizar as métricas das consultas ativas que estão em execução no momento, consulte a visualização do sistema [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md).
Para as métricas de consulta, as amostras são feitas em intervalos de um segundo. Consequentemente, diferentes execuções da mesma consulta podem retornar tempos um pouco diferentes. Além disso, os segmentos das consultas que são executados em menos de 1 segundo podem não ser registrados.
A tabela STL\$1QUERY\$1METRICS rastreia e agrega as métricas no nível da consulta, do segmento e das etapas. Para obter informações sobre os segmentos e as etapas de uma consulta, acesse [Planejamento de consulta e fluxo de trabalho de execução](c-query-planning.md). Muitas métricas (como, por exemplo, `max_rows`, `cpu_time`, etc.) são resultado da soma obtida das fatias de nós. Para obter mais informações sobre as fatias de nós, consulte [Arquitetura de sistema do data warehouse](c_high_level_system_architecture.md).
Para determinar o nível no qual uma linha relata suas métricas, examine as colunas `segment` e `step_type`.
+ Se ambos `segment` e `step_type` são `-1`, a linha relata as métricas no nível da consulta.
+ Se `segment` não é `-1` e `step_type` é `-1`, a linha relata as métricas no nível do segmento.
+ Se ambos `segment` e `step_type` são diferentes de `-1`, a linha relata as métricas no nível da etapa.
As visualizações [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md) e [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md) agregam os dados nesta visão e apresentam as informações de uma forma mais acessível.
STL\$1QUERY\$1METRICS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_QUERY_METRICS.html)
## Consulta de exemplo
Para encontrar as consultas com alto nível de tempo de CPU (mais de 1.000 segundos), execute a consulta a seguir.
```
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
```
Para encontrar as consultas ativas com uma junção de loop aninhado que retornaram mais de um milhão de linhas, execute a seguinte consulta.
```
select query, rows
from stl_query_metrics
where step_type = 15 and rows > 1000000
order by rows;
query | rows
------+-----------
25775 | 2621562702
```
Para encontrar as consultas ativas cujas execuções duraram mais de 60 segundos e que usaram menos de 10 segundos de tempo de CPU, execute a seguinte consulta.
```
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
Captura o texto da consulta para os comandos SQL.
Consulte a visualização STL\$1QUERYTEXT para capturar o SQL que foi registrado para as seguintes instruções:
+ SELECT, SELECT INTO
+ INSERT, UPDATE, DELETE
+ COPY
+ UNLOAD
+ As consultas geradas executando VACUUM e ANALYZE
+ CREATE TABLE AS (CTAS)
Para consultar a atividade dessas instruções em um determinado período de tempo, junte as visualizações STL\$1QUERYTEXT e STL\$1QUERY.
**nota**
As visualizações STL\$1QUERY e STL\$1QUERYTEXT contêm apenas informações sobre consultas, não outro utilitário e comandos DDL. Para obter uma lista e informações sobre todas as instruções executadas pelo Amazon Redshift, também é possível consultar as visualizações STL\$1DDLTEXT e STL\$1UTILITYTEXT. Para obter uma lista completa de todas as instruções executadas pelo Amazon Redshift, é possível consultar a visualização SVL\$1STATEMENTTEXT.
Consulte também [STL\$1DDLTEXT](r_STL_DDLTEXT.md), [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) e [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md).
STL\$1QUERYTEXT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
Observe que, quando o comprimento do texto da consulta é superior a 4000 caracteres, STL\$1QUERYTEXT exibe somente dados truncados. Para obter o texto completo da consulta, você pode usar UNION no texto da consulta em todas as linhas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_QUERYTEXT.html)
## Consultas de exemplo
Você pode usar a função PG\$1BACKEND\$1PID() para recuperar informações da sessão atual. Por exemplo, a consulta a seguir retorna o ID de consulta e uma parte do texto da consulta para as consultas concluídas na sessão atual.
```
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)
```
### Reconstrução de SQL armazenado
Para reconstruir o SQL armazenado na coluna `text` de STL\$1QUERYTEXT, execute uma instrução SELECT para criar SQL a partir de uma ou mais partes na coluna `text`. Antes de executar o SQL reconstruído, substitua os caracteres especiais por uma nova linha (`\n`). O resultado da instrução SELECT a seguir são linhas de SQL reconstruído no campo `query_statement`.
```
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;
```
Por exemplo, a consulta a seguir seleciona três colunas. A consulta em si tem mais de 200 caracteres e é armazenada em partes em STL\$1QUERYTEXT.
```
select
1 AS a0123456789012345678901234567890123456789012345678901234567890,
2 AS b0123456789012345678901234567890123456789012345678901234567890,
3 AS b012345678901234567890123456789012345678901234
FROM stl_querytext;
```
Nesse exemplo, a consulta é armazenada em duas partes (linhas) na coluna `text` de STL\$1QUERYTEXT.
```
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;
```
Para reconstruir o SQL armazenado em STL\$1QUERYTEXT, execute o seguinte 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();
```
Para usar o SQL reconstruído resultante em seu cliente, substitua os caracteres especiais por uma nova linha (`\n`).
```
text
------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234\nFROM stl_querytext;
```
# STL\$1REPLACEMENTS
Exibe um log que registra quando caracteres UTF-8 inválidos são substituídos pelo comando [COPY](r_COPY.md) com a opção ACCEPTINVCHARS. Uma entrada de log é adicionada à tabela STL\$1REPLACEMENTS para cada uma das 100 primeiras linhas em cada fatia de nó que exigiu pelo menos uma substituição.
STL\$1REPLACEMENTS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1NESTLOOP contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_REPLACEMENTS.html)
## Consultas de exemplo
O exemplo a seguir retorna as substituições da operação COPY mais recente.
```
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
Para manter a disponibilidade contínua após certos eventos internos, o Amazon Redshift pode reiniciar uma sessão ativa com um novo ID de processo (PID). Quando o Amazon Redshift reinicia uma sessão, a tabela STL\$1RESTARTED\$1SESSIONS registra o PID novo e o antigo.
Para obter mais informações, consulte os exemplos a seguir nesta seção.
STL\$1RESTARTED\$1SESSIONS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_RESTARTED_SESSIONS.html)
## Consultas de exemplo
O exemplo a seguir une as tabelas STL\$1RESTARTED\$1SESSIONS e STL\$1SESSIONS para mostrar os nomes dos usuários das sessões que foram reiniciadas.
```
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
Contém detalhes das etapas de *retorno* nas consultas. Uma etapa de retorno obtém os resultados das consultas concluídas nos nós de computação para o nó líder. O nó de liderança, em seguida, mescla os dados e retorna os resultados ao cliente que fez a solicitação. Para as consultas concluídas em um nó líder, a etapa de retorno obtém os resultados para o cliente.
Uma consulta consiste em vários segmentos e cada segmento consiste em uma ou mais etapas. Para obter mais informações, consulte [Processamento de consulta](c-query-processing.md).
O STL\$1RETURNS é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1RETURN contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_RETURN.html)
## Consultas de exemplo
A consulta a seguir mostra quais etapas da consulta mais recente foram realizadas em cada fatia.
```
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
Registra o tempo de transferência e outras métricas de performance.
Use a tabela STL\$1S3CLIENT para encontrar o tempo gasto na transferência de dados do Amazon S3.
STL\$1S3CLIENT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_S3CLIENT.html)
## Consulta de exemplo
A consulta a seguir retorna o tempo gasto para carregar arquivos usando o comando COPY.
```
select slice, key, transfer_time
from stl_s3client
where query = pg_last_copy_id();
```
Resultado
```
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
```
A consulta a seguir converte `start_time` e `end_time` em um carimbo de data e hora.
```
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
Registra erros encontrados por uma fatia ao carregar um arquivo do Amazon S3.
Use STL\$1S3CLIENT\$1ERROR para encontrar detalhes para erros encontrados durante a transferência de dados do Amazon S3 como parte de um comando COPY.
STL\$1S3CLIENT\$1ERROR permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_S3CLIENT_ERROR.html)
## Observações de uso
Se você encontrar vários erros com "Connection timed out", pode haver um problema de rede. Se você estiver usando o Roteamento por VPC aprimorado, verifique se existe um caminho de rede válido entre a VPC do cluster e seus recursos de dados. Para obter mais informações, consulte [Roteamento aprimorado de VPC do Amazon Redshift Spectrum](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html).
## Consulta de exemplo
A consulta a seguir retorna os erros dos comandos COPY concluídos durante a sessão atual.
```
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;
```
Resultado
```
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
Contém os detalhes das etapas de *gravação* nas consultas. Uma etapa de gravação salva o stream de entrada em uma tabela transitória. Uma tabela transitória é uma tabela temporária que armazena os resultados intermediários durante a execução da consulta.
Uma consulta consiste em vários segmentos e cada segmento consiste em uma ou mais etapas. Para obter mais informações, consulte [Processamento de consulta](c-query-processing.md).
STL\$1SAVE é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1SAVE contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SAVE.html)
## Consultas de exemplo
A consulta a seguir mostra quais etapas de salvamento da consulta mais recente foram realizadas em cada fatia.
```
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
Analisa as etapas de varredura de tabelas nas consultas. O número da etapa para as linhas dessa tabela é sempre 0, pois a varredura é a primeira etapa em um segmento.
STL\$1SCAN permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1SCAN contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SCAN.html)
## Tipos de varredura
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SCAN.html)
## Observações de uso
Idealmente, o número de `rows` deve estar relativamente perto do número de `rows_pre_filter`. Uma diferença grande entre `rows` e `rows_pre_filter` indica que o mecanismo de execução está pesquisando linhas que serão descartadas mais tarde, o que é ineficiente. A diferença entre `rows_pre_filter` e `rows_pre_user_filter` é o número de linhas fantasma na varredura. Execute o comando VACUUM para remover as linhas marcadas para exclusão. A diferença entre `rows` e `rows_pre_user_filter` é o número de linhas filtradas pela consulta. Se muitas linhas estiverem sendo rejeitadas pelo filtro do usuário, reveja a escolha de coluna de classificação ou, se isso for devido a uma região extensa não classificada, execute uma limpeza.
## Consultas de exemplo
O exemplo a seguir mostra que `rows_pre_filter` é maior do que `rows_pre_user_filter`, pois a tabela tem linhas excluídas que não foram limpadas (linhas fantasma).
```
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
Registra a ocorrência, o time stamp, o XID e outras informações úteis quando uma cota de esquema é excedida.
STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SCHEMA_QUOTA_VIOLATIONS.html)
## Consultas de exemplo
A consulta a seguir mostra o resultado da violação de cota:
```
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;
```
Essa consulta retorna o seguinte exemplo de resultado para o esquema especificado:
```
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
Retorna as informações sobre o histórico da sessão do usuário.
A diferença entre a STL\$1SESSIONS e a STV\$1SESSIONS é que a STL\$1SESSIONS contém o histórico das sessões enquanto a STV\$1SESSIONS contém as sessões atuais ativas.
STL\$1SESSIONS permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SESSIONS.html)
## Consultas de exemplo
Para visualizar o histórico da sessão do banco de dados TICKIT, digite a seguinte consulta:
```
select starttime, process, user_name, timeout_sec, timed_out
from stl_sessions
where db_name='tickit' order by starttime;
```
Essa consulta retorna os seguintes dados de saída de exemplo:
```
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
Exibe as etapas de execução da classificação nas consultas, como as etapas que usam o processamento de ORDER BY.
STL\$1SORT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1SORT contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SORT.html)
## Consultas de exemplo
O exemplo a seguir retorna os resultados da classificação para a fatia 0 e o segmento 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
Registra todos os erros vistos pelo cliente SSH.
STL\$1SSHCLIENT\$1ERROR permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_SSHCLIENT_ERROR.html)
# STL\$1STREAM\$1SEGS
Lista a relação entre os streams e os segmentos simultâneos.
Neste contexto, os fluxos são do Amazon Redshift. Essa visão do sistema não se aplica a [Ingestão de streaming para uma visão materializada](materialized-view-streaming-ingestion.md).
STL\$1SSHCLIENT\$1ERROR é visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1STREAM\$1SEGS contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_STREAM_SEGS.html)
## Consultas de exemplo
Para visualizar a relação entre streams e segmentos simultâneos para a consulta mais recente, digite a seguinte consulta:
```
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
Exibe informações para identificar e resolver conflitos de transações com tabelas de banco de dados.
Um conflito de transações ocorre quando dois ou mais usuários estão executando consultas e alterando linhas de dados de tabelas, de modo que suas transações não podem ser serializadas. A transação que executa uma instrução que poderia quebrar a serialização é interrompida e revertida. Sempre que ocorre um conflito de transação, o Amazon Redshift grava uma linha de dados na tabela de sistema STL\$1TR\$1CONFLICT contendo detalhes sobre a transação cancelada. Para obter mais informações, consulte [Níveis de isolamento no Amazon Redshift](c_serial_isolation.md).
STL\$1TR\$1CONFLICT só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_TR_CONFLICT.html)
## Consulta de exemplo
Para obter informações sobre os conflitos que envolvem uma tabela específica, execute uma consulta especificando o ID da tabela:
```
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)
```
Você pode obter o ID da tabela na seção DETAIL da mensagem de erro das violações de serialização (erro 1023).
# STL\$1UNDONE
Exibe informações sobre as transações que foram desfeitas.
STL\$1UNDONE permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_UNDONE.html)
## Consulta de exemplo
Para visualizar um log conciso de todas as transações de desfazer, digite o seguinte comando:
```
select xact_id, xact_id_undone, table_id from stl_undone;
```
Este comando retorna a seguinte saída de exemplo:
```
xact_id | xact_id_undone | table_id
---------+----------------+----------
1344 | 1344 | 100192
1326 | 1326 | 100192
1551 | 1551 | 100192
(3 rows)
```
# STL\$1UNIQUE
Analisa as etapas de execução que ocorrem quando uma função DISTINCT é usada na lista SELECT, ou quando duplicações são removidas de uma consulta UNION ou INTERSECT.
STL\$1UNIQUE permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1UNIQUE contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_UNIQUE.html)
## Consultas de exemplo
Suponha que você execute a seguinte consulta:
```
select distinct eventname
from event order by 1;
```
Assumindo que o ID da consulta anterior seja 6313, o exemplo a seguir mostra o número de linhas produzidas pela etapa exclusiva para cada fatia nos segmentos 0 e 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
Registra os detalhes de uma operação de descarregamento.
A tabela STL\$1UNLOAD\$1LOG registra uma linha para cada arquivo criado por uma instrução UNLOAD. Por exemplo, se um UNLOAD criar 12 arquivos, a STL\$1UNLOAD\$1LOG conterá 12 linhas correspondentes.
STL\$1UNLOAD\$1LOG permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1UNLOAD\$1LOG contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar as visualizações de monitoramento SYS [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md) e [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_UNLOAD_LOG.html)
## Consulta de exemplo
Para obter uma lista dos arquivos que foram gravados no Amazon S3 por um comando UNLOAD, você pode chamar uma operação de lista do Amazon S3 após a conclusão do UNLOAD. Você também pode consultar STL\$1UNLOAD\$1LOG.
A consulta a seguir retorna o nome do caminho para os arquivos que foram criados por um UNLOAD para a última consulta concluída:
```
select query, substring(path,0,40) as path
from stl_unload_log
where query = pg_last_query_id()
order by path;
```
Este comando retorna a seguinte saída de exemplo:
```
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
A visualização STL\$1USAGE\$1CONTROL contém informações que são registradas quando um limite de uso é atingido. Para obter mais informações sobre limites de uso, consulte “[Gerenciar limites de uso](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-usage-limits.html)” no *Guia de gerenciamento de clusters do Amazon Redshift*.
STL\$1USAGE\$1CONTROL é visível somente para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_USAGE_CONTROL.html)
## Consulta de exemplo
O exemplo de SQL a seguir retorna algumas das informações registradas em log quando um limite de uso é atingido.
```
select query, pid, eventtime, feature_type
from stl_usage_control
order by eventtime desc
limit 5;
```
# STL\$1USERLOG
Registra os detalhes das seguintes alterações de um usuário de banco de dados:
+ Criar usuário
+ Descartar usuário
+ Alterar usuário (renomear)
+ Alterar usuário (alterar as propriedades)
STL\$1USERLOG só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1USERLOG](SYS_USERLOG.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_USERLOG.html)
## Consultas de exemplo
O exemplo a seguir executa quatro ações do usuário e, em seguida, consulta a visualização 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
Captura o texto de comandos não SELECT SQL executados no banco de dados.
Consulte a visualização STL\$1UTILITYTEXT para capturar o seguinte subconjunto de instruções SQL que foram executadas no sistema:
+ 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
Consulte também [STL\$1DDLTEXT](r_STL_DDLTEXT.md), [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) e [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md).
Use as colunas STARTTIME e ENDTIME para saber quais instruções foram registradas em um determinado período. Os blocos longos de texto SQL são quebrados em linhas de 200 caracteres; a coluna SEQUENCE identifica os fragmentos de texto que pertencem a uma única instrução.
A tabela de sistema STL\$1UTILITYTEXT permite as operações MANUAL e AUTO REFRESH nas visões materializadas. Para identificar AUTO REFRESH em visões materializadas, encontre a coluna `label`. Todas as consultas AUTO REFRESH têm um rótulo com o valor `maintenance`.
STL\$1UTILITYTEXT permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_UTILITYTEXT.html)
## Consultas de exemplo
A consulta a seguir retorna o texto dos comandos de “utilitário” que foram executados em 26 de janeiro de 2012. Nesse caso, alguns comandos SET e um SHOW ALL foram executados:
```
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'
...
```
### Reconstrução de SQL armazenado
Para reconstruir o SQL armazenado na coluna `text` de STL\$1UTILITYTEXT, execute uma instrução SELECT para criar SQL a partir de uma ou mais partes na coluna `text`. Antes de executar o SQL reconstruído, substitua os caracteres especiais por uma nova linha (`\n`). O resultado da instrução SELECT a seguir são linhas de SQL reconstruído no campo `query_statement`.
```
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;
```
Por exemplo, a consulta a seguir define query\$1group como uma string de zeros. A consulta em si tem mais de 200 caracteres e é armazenada em partes em STL\$1UTILITYTEXT.
```
set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000';
```
Nesse exemplo, a consulta é armazenada em duas partes (linhas) na coluna `text` de STL\$1UTILITYTEXT.
```
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';
```
Para reconstruir o SQL armazenado em STL\$1UTILITYTEXT, execute o seguinte 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();
```
Para usar o SQL reconstruído resultante em seu cliente, substitua os caracteres especiais por uma nova linha (`\n`).
```
query_statement
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000';
```
# STL\$1VACUUM
Exibe as estatísticas relativas a linhas e blocos para as tabelas que foram limpadas.
A exibição mostra informações específicas de quando cada operação de vácuo começou e terminou e demonstra os benefícios de executar a operação. Para obter informações sobre os requisitos para executar este comando, consulte a descrição do comando [VACUUM](r_VACUUM_command.md).
STL\$1VACUUM só permanece visível para superusuários. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_VACUUM.html)
## Consultas de exemplo
A consulta a seguir relata as estatísticas de limpeza para a tabela 108313. A tabela foi limpada depois de uma série de inserções e exclusões.
```
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
```
No início de VACUUM, a tabela continha 1.950 linhas armazenadas em 28 blocos de 1 MB. O Amazon Redshift estimou que poderia recuperar 984 ou 17 blocos de espaço em disco com uma operação de limpeza.
Na linha do status Finished (Concluído), a coluna ROWS mostra um valor de 966 e o valor da coluna BLOCKS é 11, abaixo de 28. A limpeza recuperou a quantidade estimada de espaço em disco, sem linhas ou espaço recuperáveis após a conclusão da operação de limpeza.
Na fase de classificação (transação 15126), a limpeza ignorou a tabela, pois as linhas foram inseridas na ordem da chave de classificação.
O exemplo a seguir mostra as estatísticas de uma limpeza com SORT ONLY na tabela SALES (tabela 110116 neste exemplo) após uma grande operação INSERT:
```
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
Analisa as etapas da consulta que realizam funções da janela.
STL\$1WINDOW permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
STL\$1WINDOW contém apenas as consultas executadas nos principais clusters provisionados. Ele não contém consultas executadas em clusters de escalabilidade simultânea ou em namespaces sem servidor. Para acessar os planos de explicação das consultas executadas em clusters principais, clusters de escalabilidade simultânea e namespaces sem servidor, recomendamos usar a visualização de monitoramento SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_WINDOW.html)
## Consultas de exemplo
O exemplo a seguir retorna os resultados da função de janela para a fatia 0 e o segmento 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
Registra todos os erros relacionados a WLM ocorridos.
STL\$1WLM\$1ERROR permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_WLM_ERROR.html)
# STL\$1WLM\$1RULE\$1ACTION
Registra detalhes sobre as ações resultantes das regras de monitoramento de consultas de WLM associadas às filas definidas pelo usuário. Para obter mais informações, consulte [Regras de monitoramento de consulta do WLM](cm-c-wlm-query-monitoring-rules.md).
STL\$1WLM\$1RULE\$1ACTION permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_WLM_RULE_ACTION.html)
## Consultas de exemplo
O exemplo a seguir encontra as consultas que foram interrompidas por uma regra de monitoramento de consulta.
```
Select query, rule
from stl_wlm_rule_action
where action = 'abort'
order by query;
```
# STL\$1WLM\$1QUERY
Contém um registro de cada tentativa de execução de uma consulta em uma classe de serviço processada pelo WLM.
STL\$1WLM\$1QUERY permanece visível para todos os usuários. Os superusuários podem ver todas as linhas; usuários regulares podem ver somente seus próprios dados. Para obter mais informações, consulte [Visibilidade de dados em tabelas e visualizações de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Alguns ou todos os dados nessa tabela também podem ser encontrados na exibição de monitoramento SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Os dados na exibição de monitoramento SYS são formatados para serem mais fáceis de usar e compreender. É recomendável usar a exibição de monitoramento SYS nas consultas.
## Colunas da tabela
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/pt_br/redshift/latest/dg/r_STL_WLM_QUERY.html)
## Consultas de exemplo
**Visualização do tempo médio da consulta em filas e em execução**
A consulta a seguir mostra a configuração atual das classes de serviço maiores do que 4. Para obter uma lista dos IDs de classe de serviço, consulte [IDs da classe de serviço do WLM](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids).
A consulta a seguir retorna o tempo médio (em microssegundos) que cada consulta passou em filas de consultas e em execução para cada classe de serviço.
```
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;
```
Essa consulta retorna os seguintes dados de saída de exemplo:
```
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)
```
**Visualização do tempo máximo das consultas em filas e em execução**
A consulta a seguir retorna o tempo máximo (em microssegundos) que uma consulta passou em todas as filas de consultas e em execução para cada classe de serviço.
```
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)
```