Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Vistas de monitoreo de SYS
Las *vistas de monitoreo* son vistas del sistema en Amazon Redshift que se utilizan para monitorizar el uso de recursos de consulta y carga de trabajo de los clústeres y grupos de trabajo sin servidor. Estas vistas se encuentran en el esquema `pg_catalog`. Para mostrar la información que proporcionan estas vistas, ejecute las instrucciones SELECT de SQL.
A menos que se indique lo contrario, estas vistas están disponibles para clústeres de Amazon Redshift y grupos de trabajo de Amazon Redshift sin servidor.
*SYS\$1SERVERLESS\$1USAGE* recopila datos de uso de Amazon Redshift sin servidor únicamente.
**Topics**
+ [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md)
+ [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md)
+ [SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG](SYS_APPLIED_MASKING_POLICY_LOG.md)
+ [SYS\$1AUTOMATIC\$1OPTIMIZATION](SYS_AUTOMATIC_OPTIMIZATION.md)
+ [SYS\$1AUTO\$1TABLE\$1OPTIMIZATION](r_SYS_AUTO_TABLE_OPTIMIZATION.md)
+ [SYS\$1CHILD\$1QUERY\$1TEXT](SYS_CHILD_QUERY_TEXT.md)
+ [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md)
+ [SYS\$1COPY\$1JOB](SYS_COPY_JOB.md)
+ [SYS\$1COPY\$1JOB\$1DETAIL](SYS_COPY_JOB_DETAIL.md)
+ [SYS\$1COPY\$1JOB\$1INFO](SYS_COPY_JOB_INFO.md)
+ [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md)
+ [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md)
+ [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md)
+ [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md)
+ [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md)
+ [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md)
+ [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md)
+ [SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION](SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.md)
+ [SYS\$1INTEGRATION\$1ACTIVITY](r_SYS_INTEGRATION_ACTIVITY.md)
+ [SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY](r_SYS_INTEGRATION_TABLE_ACTIVITY.md)
+ [SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE](r_SYS_INTEGRATION_TABLE_STATE_CHANGE.md)
+ [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md)
+ [SYS\$1LUDF\$1DETAIL](SYS_LUDF_DETAIL.md)
+ [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md)
+ [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md)
+ [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md)
+ [SYS\$1MV\$1STATE](SYS_MV_STATE.md)
+ [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md)
+ [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md)
+ [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md)
+ [SYS\$1QUERY\$1EXPLAIN](SYS_QUERY_EXPLAIN.md)
+ [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md)
+ [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md)
+ [SYS\$1REDSHIFT\$1TEMPLATE](SYS_REDSHIFT_TEMPLATE.md)
+ [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md)
+ [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md)
+ [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md)
+ [SYS\$1SERVERLESS\$1USAGE](SYS_SERVERLESS_USAGE.md)
+ [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md)
+ [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md)
+ [SYS\$1STREAM\$1SCAN\$1ERRORS](r_SYS_STREAM_SCAN_ERRORS.md)
+ [SYS\$1STREAM\$1SCAN\$1STATES](r_SYS_STREAM_SCAN_STATES.md)
+ [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md)
+ [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md)
+ [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md)
+ [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md)
+ [SYS\$1USERLOG](SYS_USERLOG.md)
+ [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md)
# SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY
Registra detalles para las operaciones de análisis de compresión durante los comandos COPY o ANALYZE COMPRESSION.
SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_ANALYZE_COMPRESSION_HISTORY.html)
## Consultas de ejemplo
El siguiente ejemplo inspecciona los detalles del análisis de compresión en la tabla `lineitem` por el último comando COPY ejecutado en la misma sesión.
```
select transaction_id, table_id, btrim(table_name) as table_name, column_position, old_encoding, new_encoding, mode
from sys_analyze_compression_history
where transaction_id = (select transaction_id from sys_query_history where query_id = pg_last_copy_id()) order by column_position;
transaction_id | table_id | table_name | column_position | old_encoding | new_encoding | mode
-----------------+-------------+------------+-----------------+-----------------+-----------------+-------------
8196 | 248126 | lineitem | 0 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 1 | mostly32 | lzo | ON
8196 | 248126 | lineitem | 2 | lzo | delta32k | ON
8196 | 248126 | lineitem | 3 | delta | delta | ON
8196 | 248126 | lineitem | 4 | bytedict | bytedict | ON
8196 | 248126 | lineitem | 5 | mostly32 | mostly32 | ON
8196 | 248126 | lineitem | 6 | delta | delta | ON
8196 | 248126 | lineitem | 7 | delta | delta | ON
8196 | 248126 | lineitem | 8 | lzo | zstd | ON
8196 | 248126 | lineitem | 9 | runlength | zstd | ON
8196 | 248126 | lineitem | 10 | delta | lzo | ON
8196 | 248126 | lineitem | 11 | delta | delta | ON
8196 | 248126 | lineitem | 12 | delta | delta | ON
8196 | 248126 | lineitem | 13 | bytedict | zstd | ON
8196 | 248126 | lineitem | 14 | bytedict | zstd | ON
8196 | 248126 | lineitem | 15 | text255 | zstd | ON
(16 rows)
```
# SYS\$1ANALYZE\$1HISTORY
Registra los detalles de las operaciones [ANALYZE](https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE.html).
SYS\$1ANALYZE\$1HISTORY solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_ANALYZE_HISTORY.html)
## Consultas de ejemplo
```
user_id | transaction_id | database_name | schema_name | table_name | table_id | is_automatic | Status | start_time | end_time | rows | modified_rows | analyze_threshold_percent | last_analyze_time
---------+----------------+---------------+-------------+---------------------+----------+--------------+--------+----------------------------+----------+-----------------+------+---------------+---------------------------+---------------------
101 | 8006 | dev | public | test_table_562bf8dc | 110427 | f | Full | 2023-09-21 18:33:08.504646 | 2023-09-21 18:33:24.296498 | 5 | 5 | 0 | 2000-01-01 00:00:00
```
# SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG
Utilice SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG para rastrear la aplicación de políticas de enmascaramiento de datos dinámicos en consultas que hacen referencia a relaciones protegidas por DDM.
SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG es visible para los usuarios siguientes:
+ Superusuarios
+ Usuarios con el rol `sys:operator`
+ Usuarios con el permiso ACCESS SYSTEM TABLE
Los usuarios normales verán 0 filas.
Tenga en cuenta que SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG no es visible para los usuarios con el rol `sys:secadmin`.
Para obtener más información sobre el enmascaramiento de datos dinámico, vaya a [Enmascaramiento de datos dinámico](t_ddm.md).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_APPLIED_MASKING_POLICY_LOG.html)
## Consultas de ejemplo
El siguiente ejemplo muestra que la política de enmascaramiento `mask_credit_card_full` está adjunta a la tabla `credit_db.public.credit_cards`.
```
select policy_name, database_name, relation_name, schema_name, relation_kind
from sys_applied_masking_policy_log;
policy_name | database_name | relation_name | schema_name | relation_kind
----------------------+---------------+---------------+-------------+---------------
mask_credit_card_full | credit_db | credit_cards | public | table
(1 row)
```
# SYS\$1AUTOMATIC\$1OPTIMIZATION
Utilice SYS\$1AUTOMATIC\$1OPTIMIZATION para ver los detalles de las tareas que Amazon Redshift ejecuta para la optimización automática, también conocida como características automatizadas. Para obtener más información sobre la automatización automática, consulte [Optimización automática de bases de datos](c_autonomics.md).
SYS\$1AUTOMATIC\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_AUTOMATIC_OPTIMIZATION.html)
## Notas de uso
La columna compute\$1type estará vacía en el caso de los clústeres sin servidor, ya que no diferenciamos los recursos de computación primarios de los de escala primaria. Los recursos de computación del clúster sin servidor se miden por el uso de unidades de procesamiento de Redshift (RPU). Para obtener más información, consulte [Capacidad informática para Amazon Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-capacity.html).
## Ejemplos
La siguiente consulta muestra las optimizaciones automáticas realizadas en la tabla 155259.
```
SELECT pid, trim(task_type) as task_type,
trim(database) as database,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE object_ids like '%155259%'
AND status = 'Task completed successfully';
task_type | database | status | event | event_time
------------+----------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
```
La siguiente consulta muestra todas las optimizaciones automáticas de “VacuumSort” ejecutadas. Para obtener más información sobre “VacuumSort”, consulte [Clasificación automática de tablas](t_Reclaiming_storage_space202.md#automatic-table-sort).
```
SELECT trim(task_type) as task_type,
trim(database) as database,
trim(object_type) as object_type,
trim(object_ids) as object_ids,
trim(status) as status,
trim(event) as event,
event_time
from SYS_AUTOMATIC_OPTIMIZATION
WHERE task_type like '%VacuumSort%'
AND status = 'Task completed successfully';
task_type | database | object_type | object_ids | status | event | event_time
------------+----------------+-------------+------------+-----------------------------+-----------+----------------------------
VacuumSort | tpcds_100g_oob | table | 155301 | Task completed successfully | Completed | 2025-12-22 07:14:00.065391
VacuumSort | tpcds_100g_oob | table | 155303 | Task completed successfully | Completed | 2025-12-22 07:14:09.158251
VacuumSort | tpcds_100g_oob | table | 155291 | Task completed successfully | Completed | 2025-12-22 07:17:06.61164
VacuumSort | tpcds_100g_oob | table | 155293 | Task completed successfully | Completed | 2025-12-22 07:17:37.015069
VacuumSort | tpcds_100g_oob | table | 155281 | Task completed successfully | Completed | 2025-12-22 07:18:54.903935
VacuumSort | tpcds_100g_oob | table | 155279 | Task completed successfully | Completed | 2025-12-22 07:20:13.960002
VacuumSort | tpcds_100g_oob | table | 155271 | Task completed successfully | Completed | 2025-12-22 07:21:26.095549
VacuumSort | tpcds_100g_oob | table | 155267 | Task completed successfully | Completed | 2025-12-22 07:22:48.119249
VacuumSort | tpcds_100g_oob | table | 155269 | Task completed successfully | Completed | 2025-12-22 07:24:12.010424
VacuumSort | tpcds_100g_oob | table | 155263 | Task completed successfully | Completed | 2025-12-22 07:25:35.958388
VacuumSort | tpcds_100g_oob | table | 155265 | Task completed successfully | Completed | 2025-12-22 07:26:40.580395
VacuumSort | tpcds_100g_oob | table | 155259 | Task completed successfully | Completed | 2025-12-22 07:27:15.943018
(12 rows)
```
# SYS\$1AUTO\$1TABLE\$1OPTIMIZATION
Registra las acciones automatizadas realizadas por Amazon Redshift en tablas definidas para la optimización automática.
SYS\$1AUTO\$1TABLE\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_AUTO_TABLE_OPTIMIZATION.html)
## Consultas de ejemplo
En el siguiente ejemplo, las filas del resultado muestran las acciones realizadas por Amazon Redshift.
```
SELECT table_id, alter_table_type, status, event_time, alter_from
FROM SYS_AUTO_TABLE_OPTIMIZATION;
table_id | alter_table_type | status | event_time | alter_from
----------+---------------------+------------------------------------------------------+-----------------------------+-----------------
118082 | sortkey | Start | 2020-08-22 19:42:20.727049 |
118078 | sortkey | Start | 2020-08-22 19:43:54.728819 |
118082 | sortkey | Start | 2020-08-22 19:42:52.690264 |
118072 | sortkey | Start | 2020-08-22 19:44:14.793572 |
118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 |
118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | SORTKEY: None;
118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | SORTKEY: None;
118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | SORTKEY: None;
118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 |
118086 | sortkey | Start | 2020-08-22 19:42:00.685255 |
118082 | sortkey | Start | 2020-08-22 19:43:34.69531 |
118072 | sortkey | Start | 2020-08-22 19:44:46.703331 |
118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 |
118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 |
116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 |
110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 |
```
# SYS\$1CHILD\$1QUERY\$1TEXT
Devuelve el texto de SQL de una consulta secundaria.
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_CHILD_QUERY_TEXT.html)
## Consultas de ejemplo
En el siguiente ejemplo, las filas del resultado muestran las acciones realizadas por Amazon Redshift.
```
SELECT * from sys_child_query_text where query_id = '34487366' order by child_query_sequence asc, sequence asc;
user_id | query_id | child_query_sequence | sequence | text
--------|----------|----------------------|----------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 34899339 | 1 | 0 | /* RQEV2-aY6ZZ1ZpQK */\nwith venue as (\n select venueid,\n venuename,\n venuestate\n from venue\n), event as (\n select eventid,\n venueid,\n date
100 | 34899339 | 1 | 1 | id,\n eventname\n from event\n where eventname like '3 Doors Down'\n), users as (\n select userid\n from users\n), sales as (\n select salesid,\n pricepaid,
100 | 34899339 | 1 | 2 | \n eventid,\n buyerid\n from sales\n)\nselect e.eventname,\n v.venuename,\n count(distinct(u.userid)) as unique_customers,\n sum(s.pricepaid) as total_sal
100 | 34899339 | 1 | 3 | es\nfrom venue as v inner join event e on v.venueid = e.venueid\ninner join sales s on e.eventid = s.eventid inner join users u on s.buyerid = u.userid\ngroup by 1,2\norder by 4 desc limit 100
```
# SYS\$1CONNECTION\$1LOG
Registra los intentos de autenticación y las conexiones y desconexiones.
SYS\$1CONNECTION\$1LOG solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_CONNECTION_LOG.html)
## Consultas de ejemplo
Para ver los detalles de las conexiones abiertas, ejecute la siguiente consulta.
```
select record_time, user_name, database_name, remote_host, remote_port
from sys_connection_log
where event = 'initiating session'
and session_id not in
(select session_id from sys_connection_log
where event = 'disconnecting session')
order by 1 desc;
record_time | user_name | database_name | remote_host | remote_port
--------------------+-------------+-----------------+---------------+---------------------------------
2014-11-06 20:30:06 | rdsdb | dev | [local] |
2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111
2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333
2014-11-05 20:28:35 | rdsdb | dev | [local] |
(4 rows)
```
En el siguiente ejemplo, se refleja un intento fallido de autenticación y una correcta conexión y desconexión.
```
select event, record_time, remote_host, user_name
from sys_connection_log order by record_time;
event | record_time | remote_host | user_name
-----------------------+----------------------------+---------------+---------
authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john
authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john
initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john
disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john
(4 rows)
```
En el siguiente ejemplo, se muestra la versión del controlador ODBC, el sistema operativo del equipo cliente y el complemento utilizado para conectarse al clúster de Amazon Redshift. En este ejemplo, el complemento se utiliza para la autenticación de controladores ODBC estándar mediante un nombre de inicio de sesión y una contraseña.
```
select driver_version, os_version, plugin_name from sys_connection_log;
driver_version | os_version | plugin_name
----------------------------------------+-----------------------------------+--------------------
Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none
Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none
```
En el siguiente ejemplo, se muestra la versión del sistema operativo en el equipo cliente, la versión del controlador y la versión del protocolo.
```
select os_version, driver_version, protocol_version from sys_connection_log;
os_version | driver_version | protocol_version
--------------------------------+------------------------------+--------------------
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2
```
# SYS\$1COPY\$1JOB
Utilice SYS\$1COPY\$1JOB para ver los detalles de los comandos COPY JOB.
Esta vista contiene los comandos COPY JOB que se han creado.
SYS\$1COPY\$1JOB es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB.html)
# SYS\$1COPY\$1JOB\$1DETAIL
Utilice SYS\$1COPY\$1JOB\$1DETAIL para ver los detalles de los comandos COPY JOB.
Esta vista contiene los comandos COPY JOB que se han creado. Si COPY JOB intenta cargar un archivo y este no se carga, el archivo se omitirá en futuros intentos automáticos de COPY JOB.
SYS\$1COPY\$1JOB\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB_DETAIL.html)
El ejemplo siguiente devuelve una fila donde se muestran las entradas ingeridas.
```
SELECT * FROM SYS_COPY_JOB_DETAIL WHERE status ilike '%ingested%' limit 1;
user_id | 100
database_name | dev
job_name | many_job_4_3
job_id | 110702
file_location | saral-sqs-system4623202051-0
file_name | frenzy-9/4623202051/file_0_107
file_size | 11302
file_etag | 51b2d78ac5b5aecf4ee6f8374815ad19
modification_time | 2024-07-15 20:43:14
enqueue_time | 2024-07-15 20:44:24
status | Ingested
```
# SYS\$1COPY\$1JOB\$1INFO
Utilice SYS\$1COPY\$1JOB\$1INFO para visualizar los mensajes registrados sobre un COPY JOB.
Esta vista contiene información sobre los errores de un COPY JOB que se ha ejecutado.
SYS\$1COPY\$1JOB\$1INFO es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB_INFO.html)
# SYS\$1COPY\$1REPLACEMENTS
Muestra un registro de los momentos en que se reemplazaron caracteres UTF-8 no válidos por el comando [COPY](r_COPY.md) con la opción ACCEPTINVCHARS. Se agrega una entrada de registro a SYS\$1COPY\$1REPLACEMENTS por cada una de las 100 primeras filas de cada sector del nodo que necesitaron al menos un reemplazo.
Puede utilizar esta vista para consultar información sobre los grupos de trabajo sin servidor y los clústeres aprovisionados.
SYS\$1COPY\$1REPLACEMENTS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_REPLACEMENTS.html)
## Consultas de ejemplo
El siguiente ejemplo devuelve los reemplazos de la operación COPY más reciente.
```
select query_idp, table_id, file_name, line_number, colname
from sys_copy_replacements
where query = pg_last_copy_id();
query_id | table_id | file_name | line_number | column_name
---------+----------+-------------------------------------------------------+-------------+--------
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 123 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 456 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 789 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 012 | city
96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 119 | city
...
```
# SYS\$1DATASHARE\$1CHANGE\$1LOG
Registra la vista consolidada para realizar el seguimiento de los cambios en los datashares (recursos para compartir datos) tanto en los clústeres productores como en los consumidores.
SYS\$1DATASHARE\$1CHANGE\$1LOG es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_CHANGE_LOG.html)
## Consultas de ejemplo
En el siguiente ejemplo, se muestra una vista SYS\$1DATASHARE\$1CHANGE\$1LOG.
```
SELECT DISTINCT action
FROM sys_datashare_change_log
WHERE share_object_name LIKE 'tickit%';
action
-----------------------
"ALTER DATASHARE ADD"
```
# SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE
Utilice la vista SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE para obtener un resumen del uso de datos transferidos entre regiones debido a la consulta de uso compartido de datos entre regiones. SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE agrega detalles en el nivel de segmento.
Solo los superusuarios pueden ver SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_DATASHARE_CROSS_REGION_USAGE.html)
## Consultas de ejemplo
En el siguiente ejemplo, se muestra una vista SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE.
```
SELECT query_id, segment_id, transferred_data, source_region
from sys_datashare_cross_region_usage
where query_id = pg_last_query_id()
order by query_id, segment_id;
query_id | segment_id | transferred_data | source_region
-----------+------------+------------------+---------------
200048 | 2 | 4194304 | us-west-1
200048 | 2 | 4194304 | us-east-2
```
# SYS\$1DATASHARE\$1USAGE\$1CONSUMER
Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster consumidor.
SYS\$1DATASHARE\$1USAGE\$1CONSUMER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_USAGE_CONSUMER.html)
## Consultas de ejemplo
En el siguiente ejemplo, se muestra la vista SYS\$1DATASHARE\$1USAGE\$1CONSUMER.
```
SELECT request_type, status, trim(error) AS error
FROM sys_datashare_usage_consumer
request_type | status | error_message
----------------+--------+---------------
"GET RELATION" | 0 |
```
# SYS\$1DATASHARE\$1USAGE\$1PRODUCER
Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster productor.
SVL\$1DATASHARE\$1USAGE\$1PRODUCER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_USAGE_PRODUCER.html)
## Consultas de ejemplo
En el siguiente ejemplo, se muestra la vista SYS\$1DATASHARE\$1USAGE\$1PRODUCER.
```
SELECT DISTINCT
FROM sys_datashare_usage_producer
WHERE object_name LIKE 'tickit%';
request_type
------------------
"GET RELATION"
```
# SYS\$1EXTERNAL\$1QUERY\$1DETAIL
Utilice SYS\$1EXTERNAL\$1QUERY\$1DETAIL para visualizar los detalles de las consultas en el nivel del segmento. Cada fila representa un segmento de una determinada consulta de WLM con una serie de detalles como el número de filas procesadas, el número de bytes procesados y la información de partición de las tablas externas en Amazon S3. Cada fila de esta vista tendrá también una entrada correspondiente en la vista SYS\$1QUERY\$1DETAIL, con la diferencia de que esta última contiene más información detallada relativa al procesamiento de las consultas externas.
SYS\$1EXTERNAL\$1QUERY\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTERNAL_QUERY_DETAIL.html)
## Consultas de ejemplo
La siguiente consulta muestra los detalles de la consulta externa.
```
SELECT query_id,
segment_id,
start_time,
end_time,
total_partitions,
qualified_partitions,
scanned_files,
returned_rows,
returned_bytes,
trim(external_query_text) query_text,
trim(file_location) file_location
FROM sys_external_query_detail
ORDER BY query_id, start_time DESC
LIMIT 2;
```
Resultados de ejemplo.
```
query_id | segment_id | start_time | end_time | total_partitions | qualified_partitions | scanned_files | returned_rows | returned_bytes | query_text | file_location
----------+------------+----------------------------+----------------------------+------------------+----------------------+---------------+---------------+----------------+------------+---------------
763251 | 0 | 2022-02-15 22:32:23.312448 | 2022-02-15 22:32:24.036023 | 3 | 3 | 3 | 38203 | 2683414 | |
763254 | 0 | 2022-02-15 22:32:40.17103 | 2022-02-15 22:32:40.839313 | 3 | 3 | 3 | 38203 | 2683414 | |
```
# SYS\$1EXTERNAL\$1QUERY\$1ERROR
Puede consultar la vista del sistema SYS\$1EXTERNAL\$1QUERY\$1ERROR para obtener información acerca de los errores de análisis de Redshift Spectrum. SYS\$1EXTERNAL\$1QUERY\$1ERROR muestra un ejemplo de los errores registrados. El valor predeterminado es 10 entradas por consulta.
SYS\$1EXTERNAL\$1QUERY\$1ERROR es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTERNAL_QUERY_ERROR.html)
## Consulta de ejemplo
La siguiente consulta devuelve la lista de filas para las que se han realizado operaciones de control de datos.
```
SELECT * FROM sys_external_query_error;
```
La consulta devuelve resultados similares a los siguientes.
```
user_id query_id file_location rowid column_name original_value modified_value trigger action action_value error_code
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156
```
# SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION
Utilice SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION para ver los períodos de uso en los que Amazon Redshift ejecutó tareas de optimización automática con recursos de computación adicional. Para obtener más información sobre la automatización automática, consulte [Optimización automática de bases de datos](c_autonomics.md). Para obtener más información sobre las optimizaciones automáticas que se ejecutan con recursos de computación adicional, consulte [Asignación de recursos de computación adicional para la optimización automática de bases de datos](t_extra-compute-autonomics.md).
SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION solo está disponible para los clústeres aprovisionados.
SYS\$1AUTO\$1TABLE\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.html)
## Ejemplos
A continuación se muestra un ejemplo de consulta en la que se buscan optimizaciones automáticas realizadas el 16 de septiembre de 2025.
```
SELECT *
FROM sys_extra_compute_for_automatic_optimization
WHERE start_time BETWEEN '2025-09-16 00:00:00' AND '2025-09-16 23:59:59';
start_time | end_time | query_count | compute_seconds
---------------------+---------------------+-------------+-----------------
2025-09-16 00:00:00 | 2025-09-16 00:00:59 | 1 | 59
2025-09-16 00:01:05 | 2025-09-16 00:01:58 | 2 | 53
```
# SYS\$1INTEGRATION\$1ACTIVITY
SYS\$1INTEGRATION\$1ACTIVITY muestra detalles sobre las ejecuciones de integración completadas.
SYS\$1INTEGRATION\$1ACTIVITY solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
Para obtener información sobre las integraciones sin ETL, consulte [Uso de integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html) en la guía de administración de Amazon Redshift.
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html)
## Consultas de ejemplo
El siguiente comando SQL muestra el registro de las integraciones.
```
select * from sys_integration_activity;
integration_id | target_database | source | checkpoint_name | checkpoint_type | checkpoint_bytes | last_commit_timestamp | modified_tables | integration_start_time | integration_end_time
--------------------------------------+-----------------+--------+---------------------------------------------+------------------+------------------+-------------------------+-----------------+----------------------------+----------------------------
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_241_3_510.json | cdc | 762 | 2023-05-10 23:00:14.201 | 1 | 2023-05-10 23:00:45.054265 | 2023-05-10 23:00:46.339826
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_16329_3_17839.json | cdc | 13488 | 2023-05-11 01:33:57.411 | 2 | 2023-05-11 02:19:09.440121 | 2023-05-11 02:19:16.090492
76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_5103_3_5532.json | cdc | 1657 | 2023-05-10 23:13:14.205 | 2 | 2023-05-10 23:13:23.545487 | 2023-05-10 23:13:25.652144
```
# SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY
SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY muestra los detalles de la actividad de inserción, eliminación y actualización de las integraciones sin ETL. Se añade una fila por cada ingesta completada.
Un superusuario puede ver todas las filas de esta tabla.
Para obtener más información, consulte [Integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_ACTIVITY.html)
## Consultas de ejemplo
El siguiente comando de SQL muestra la actividad de la integración.
```
select * from sys_integration_table_activity;
integration_id | checkpoint_name | target_database | schema_name | table_name | table_id | record_time | transaction_id | inserted_rows | deleted_rows | updated_rows | bytes_ingested
--------------------------------------+-----------------+-----------------+-------------+-------------------+--------------+----------------------------+-----------------+----------------+--------------+--------------+---------------
4798e675-8f9f-4686-b05f-92c538e19629 | | sample_test2 | sample | SampleTestChannel | 111276 | 2023-05-12 12:40:30.656625 | 7736 | 2 | 0 | 0 | 125
```
# SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE
SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE: muestra los detalles de los registros de cambios de estados de tabla para las integraciones.
Un superusuario puede ver todas las filas de esta tabla.
Para obtener más información, consulte [Uso de integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html)
## Consultas de ejemplo
El siguiente comando SQL muestra el registro de las integraciones.
```
select * from sys_integration_table_state_change;
integration_id | database_name | schema_name | table_name | new_state | table_last_replicated_checkpoint | state_change_reason | record_time
--------------------------------------+---------------+-------------+------------+-----------+-------------------------------------+---------------------+----------------------------
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest79 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:50.087868
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest56 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:45.54005
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest50 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:20.362504
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest18 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:32.544084
99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest40t3s | sbtest23 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 15:49:05.186209
```
# SYS\$1LOAD\$1DETAIL
Devuelve información para realizar un seguimiento o solucionar problemas en la carga de datos.
En esta vista, se registra el progreso de cada archivo de datos mientras se carga en una tabla de base de datos.
Todos los usuarios pueden acceder a esta vista. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_DETAIL.html)
## Consultas de ejemplo
El siguiente ejemplo devuelve los detalles de la última operación COPY.
```
select query_id, trim(file_name) as file, record_time
from sys_load_detail
where query_id = pg_last_copy_id();
query_id | file | record_time
----------+----------------------------------+----------------------------
28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486
(1 row)
```
La siguiente consulta tiene entradas para una carga nueva de las tablas en la base de datos TICKIT:
```
select query_id, trim(file_name), record_time
from sys_load_detail
where file_name like '%tickit%' order by query_id;
query_id | btrim | record_time
----------+--------------------------+----------------------------
22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186
22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604
22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472
22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305
22485 | tickit/allevents_pipe.txt| 2013-02-08 20:58:29.99489
22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939
22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491
22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055
22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049
22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502
22603 | tickit/allevents_pipe.txt| 2013-02-08 21:04:14.785124
22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594
(12 rows)
```
El hecho de que se escriba un registro en el archivo de registros para esta vista de sistema no implica que la carga se haya confirmado correctamente como parte de la transacción que contiene. Para comprobar las confirmaciones de carga, consulte la vista STL\$1UTILITYTEXT y busque el registro COMMIT que corresponda a esa transacción COPY. Por ejemplo, esta consulta combina SYS\$1LOAD\$1DETAIL y STL\$1QUERY en función de una subconsulta de STL\$1UTILITYTEXT:
```
select l.query_id,rtrim(l.file_name),q.transaction_id
from sys_load_detail l, sys_query_text q
where l.query_id=q.query_id
and exists
(select xid from stl_utilitytext where xid=q.transaction_id and rtrim("text")='COMMIT');
query_id | rtrim | transaction_id
----------+---------------------------+-----------------
22600 | tickit/date2008_pipe.txt | 68311
22480 | tickit/category_pipe.txt | 68066
7508 | allusers_pipe.txt | 23365
7552 | category_pipe.txt | 23415
7576 | allevents_pipe.txt | 23429
7516 | venue_pipe.txt | 23390
7604 | listings_pipe.txt | 23445
22596 | tickit/venue_pipe.txt | 68309
22605 | tickit/listings_pipe.txt | 68316
22593 | tickit/allusers_pipe.txt | 68305
22485 | tickit/allevents_pipe.txt | 68071
7561 | allevents_pipe.txt | 23429
7541 | category_pipe.txt | 23415
7558 | date2008_pipe.txt | 23428
22478 | tickit/venue_pipe.txt | 68065
526 | date2008_pipe.txt | 2572
7466 | allusers_pipe.txt | 23365
22482 | tickit/date2008_pipe.txt | 68067
22598 | tickit/category_pipe.txt | 68310
22603 | tickit/allevents_pipe.txt | 68315
22475 | tickit/allusers_pipe.txt | 68061
547 | date2008_pipe.txt | 2572
22487 | tickit/listings_pipe.txt | 68072
7531 | venue_pipe.txt | 23390
7583 | listings_pipe.txt | 23445
(25 rows)
```
# SYS\$1LUDF\$1DETAIL
SYS\$1LUDF\$1DETAIL registra la información y las métricas de las funciones definidas por el usuario de Lambda (LUDF) que se utilizaron en una consulta concreta.
SYS\$1LUDF\$1DETAIL solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LUDF_DETAIL.html)
## Consultas de ejemplo
En el siguiente ejemplo se utiliza una UDF de Lambda en una consulta y, a continuación, se muestra cómo consultar la vista SYS\$1LUDF\$1DETAIL para ver los detalles de ejecución de la función.
```
SET SESSION AUTHORIZATION regular_user;
CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT) RETURNS INT STABLE
LAMBDA 'lambda_sum'
IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test';
CREATE TABLE t_sum(c1 int, c2 int);
INSERT INTO t_sum VALUES (4,5), (6,7);
SELECT exfunc_sum(c1,c2) FROM t_sum;
-- Switch to super user in order to inspect records in the LUDF SYS view.
SET SESSION AUTHORIZATION super_user;
select * from sys_ludf_detail;
```
Código de salida de ejemplo:
```
user_id | transaction_id | query_id | function_oid | function_position | stream_id | segment_id | step_id | lambda_function_name | start_time | end_time | total_duration | invocations | total_rows | input_bytes | output_bytes
---------+----------------+----------+--------------+-------------------+-----------+------------+---------+----------------------+----------------------------+----------------------------+----------------+-------------+------------+-------------+--------------
100 | 1463 | 1544 | 111055 | 0 | 0 | 0 | 2 | lambda_sum | 2026-01-06 17:23:25.165898 | 2026-01-06 17:23:25.165898 | 414 | 1 | 2 | 277 | 18
(1 row)
```
# SYS\$1LOAD\$1ERROR\$1DETAIL
Utilice SYS\$1LOAD\$1ERROR\$1DETAIL para visualizar los detalles de los errores del comando COPY. Cada una de las filas representa un comando COPY. Contiene tanto los comandos COPY en ejecución como los que han finalizado.
SYS\$1LOAD\$1ERROR\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_ERROR_DETAIL.html)
## Consultas de ejemplo
La siguiente consulta muestra los detalles del error de carga del comando copy de una consulta específica.
```
SELECT query_id,
table_id,
start_time,
trim(file_name) AS file_name,
trim(column_name) AS column_name,
trim(column_type) AS column_type,
trim(error_message) AS error_message
FROM sys_load_error_detail
WHERE query_id = 762949
ORDER BY start_time
LIMIT 10;
```
Resultados de ejemplo.
```
query_id | table_id | start_time | file_name | column_name | column_type | error_message
----------+----------+----------------------------+------------------------------------------+-------------+-------------+------------------------------------------------
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_000 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_001 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer
```
# SYS\$1LOAD\$1HISTORY
Utilice SYS\$1LOAD\$1HISTORY para visualizar los detalles de los comandos COPY. Cada una de las filas representa un comando COPY con estadísticas acumuladas para algunos de los campos. Contiene tanto los comandos COPY en ejecución como los que han finalizado.
SYS\$1LOAD\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_HISTORY.html)
## Consultas de ejemplo
La siguiente consulta muestra las filas, los bytes, las tablas y el origen de datos cargados de comandos de copia específicos.
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
WHERE query_id IN (6389,490791,441663,74374,72297)
ORDER BY query_id,
data_source DESC;
```
Resultados de ejemplo.
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------+-----------------------------------------------------------------------+-------------+---------------
6389 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196240296158
72297 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
74374 | ship_mode | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/ship_mode/ | 20 | 1320
441663 | income_band | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/income_band/ | 20 | 2152
490791 | customer_address | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/customer_address/ | 6000000 | 722924305
```
La siguiente consulta muestra las filas, los bytes, las tablas y el origen de datos cargados de comandos copy.
```
SELECT query_id,
table_name,
data_source,
loaded_rows,
loaded_bytes
FROM sys_load_history
ORDER BY query_id DESC
LIMIT 10;
```
Resultados de ejemplo.
```
query_id | table_name | data_source | loaded_rows | loaded_bytes
----------+------------------------+-----------------------------------------------------------------------------+-------------+-----------------
491058 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808
490947 | web_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_sales/ | 720000376 | 22971988122819
490923 | web_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_returns/ | 71997522 | 96597496325
490918 | web_page | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_page/ | 3000 | 1320
490907 | warehouse | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/warehouse/ | 20 | 1320
490902 | time_dim | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/time_dim/ | 86400 | 1320
490876 | store_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_sales/ | 2879987999 | 151666241887933
490870 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196405607941
490865 | store | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store/ | 1002 | 365507
```
La siguiente consulta muestra las filas y los bytes cargados del comando copy.
```
SELECT date_trunc('day',start_time) AS exec_day,
SUM(loaded_rows) AS loaded_rows,
SUM(loaded_bytes) AS loaded_bytes
FROM sys_load_history
GROUP BY exec_day
ORDER BY exec_day DESC;
```
Resultados de ejemplo.
```
exec_day | loaded_rows | loaded_bytes
---------------------+-------------+------------------
2022-01-20 00:00:00 | 6347386005 | 258329473070606
2022-01-19 00:00:00 | 19042158015 | 775198502204572
2022-01-18 00:00:00 | 38084316030 | 1550294469446883
2022-01-17 00:00:00 | 25389544020 | 1033271084791724
2022-01-16 00:00:00 | 19042158015 | 775222736252792
2022-01-15 00:00:00 | 19834245387 | 798122849155598
2022-01-14 00:00:00 | 75376544688 | 3077040926571384
```
# SYS\$1MV\$1REFRESH\$1HISTORY
Los resultados incluyen información sobre el historial de actualizaciones de todas las vistas materializadas. Los resultados incluyen el tipo de actualización, como manual o automática, y el estado de la actualización más reciente.
SYS\$1MV\$1REFRESH\$1HISTORY está visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_MV_REFRESH_HISTORY.html)
## Consultas de ejemplo
La siguiente consulta muestra el historial de actualizaciones de las vistas materializadas.
```
SELECT user_id,
session_id,
transaction_id,
database_name,
schema_name,
mv_id,
mv_name,
refresh_type,
status,
start_time,
end_time,
duration,
consumer_account,
consumer_region,
consumer_namespace
from sys_mv_refresh_history;
```
La consulta devuelve el siguiente ejemplo de salida:
```
user_id | session_id | transaction_id | database_name | schema_name | mv_id | mv_name | refresh_type | status | start_time | end_time | duration | consumer_account | consumer_region | consumer_namespace
---------+------------+----------------+---------------+----------------------------+--------+--------------------+----------------+------------------------------------------------------------------------------------------------------+----------------------------+----------------------------+-----------+------------------+-----------------+------------------------------------
1 | 1073815659 | 15066 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | MV was already updated | 2023-10-26 15:59:20.952179 | 2023-10-26 15:59:20.952866 | 687 | | |
1 | 1073815659 | 15068 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | MV was already updated | 2023-10-26 15:59:21.008049 | 2023-10-26 15:59:21.008658 | 609 | | |
1 | 1073815659 | 15070 | ext_db | producer_schema | 203779 | producer_mv | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:21.064252 | 2023-10-26 15:59:21.064885 | 633 | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af
1 | 1073815659 | 15074 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:29.693329 | 2023-10-26 15:59:43.482842 | 13789513 | | |
1 | 1073815659 | 15076 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | Refresh successfully recomputed MV from scratch | 2023-10-26 15:59:43.550184 | 2023-10-26 15:59:47.880833 | 4330649 | | |
1 | 1073815659 | 15078 | dev | test_stl_mv_refresh_schema | 203779 | mv_refresh_error | Manual | Refresh failed due to an internal error | 2023-10-26 15:59:47.949052 | 2023-10-26 15:59:52.494681 | 4545629 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh failed because materialized view test_stl_mv_refresh_schema.child was not refreshed. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | |
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh skipped because materialized view test_stl_mv_refresh_schema.child was not refreshed.| 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633
(10 rows)
```
# SYS\$1MV\$1STATE
Los resultados incluyen información sobre el estado de todas las vistas materializadas. Incluye información de la tabla base, propiedades del esquema e información sobre eventos recientes, como la eliminación de una columna.
SYS\$1MV\$1STATE es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_MV_STATE.html)
## Consultas de ejemplo
En la siguiente consulta se muestra el estado de la vista materializada.
```
select * from sys_mv_state;
```
La consulta devuelve el siguiente ejemplo de salida:
```
user_id | transaction_id | database_name | event_desc | start_time | base_table_database_name | base_table_schema | base_table_name | mv_schema | mv_name | state
---------+----------------+---------------+-----------------------------+----------------------------+--------------------------+-------------------+---------------------+-------------+----------------------------+--------------
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788268 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Recompute
106 | 12724 | tickit_db | ALTER TABLE ALTER DISTSTYLE | 2023-07-26 14:59:51.409014 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.822928 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051244 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857755 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051358 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788159 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857799 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788327 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Recompute
106 | 12727 | tickit_db | ALTER TABLE ALTER SORTKEY | 2023-07-26 15:00:08.006235 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute
106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.82297 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051321 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable
```
# SYS\$1PROCEDURE\$1CALL
Utilice la vista SYS\$1PROCEDURE\$1CALL para obtener información sobre las llamadas a procedimientos almacenados, incluida la hora de inicio, la hora de finalización, el estado de una llamada a un procedimiento almacenado y la jerarquía de llamadas para las llamadas a procedimientos almacenados anidados. Cada llamada de procedimiento almacenado recibe un ID de consulta.
SYS\$1STORED\$1PROC\$1CALL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_PROCEDURE_CALL.html)
## Consultas de ejemplo
La siguiente consulta devuelve una jerarquía de llamadas a procedimientos almacenados anidados.
```
select query_id, datediff(seconds, start_time, end_time) as elapsed_time, status, trim(query_text) as call, caller_procedure_query_id from sys_procedure_call;
```
Resultados de ejemplo.
```
query_id | elapsed_time | status | call | caller_procedure_query_id
----------+--------------+---------+--------------------------------------------------+---------------------------
3087 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d(1) | 3085
3085 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d_2(1); |
(2 rows)
```
# SYS\$1PROCEDURE\$1MESSAGES
SYS\$1STORED\$1PROC\$1MESSAGES es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_PROCEDURE_MESSAGES.html)
## Consultas de ejemplo
La siguiente consulta muestra un ejemplo de salida de SYS\$1PROCEDURE\$1MESSAGES.
```
select transaction_id, query_id, record_time, log_level, trim(message), line_number from sys_procedure_messages;
```
```
transaction_id | query_id | record_time | log_level | btrim | line_number
---------------+----------+----------------------------+-----------+---------------------------+-------------
25267 | 80562 | 2023-07-17 14:38:31.910136 | NOTICE | test_notice_msg_b9f1e749 | 8
25267 | 80562 | 2023-07-17 14:38:31.910002 | LOG | test_log_msg_833c7420 | 6
25267 | 80562 | 2023-07-17 14:38:31.910111 | INFO | test_info_msg_651373d9 | 7
25267 | 80562 | 2023-07-17 14:38:31.910154 | WARNING | test_warning_msg_831c5747 | 9
(4 rows)
```
# SYS\$1QUERY\$1DETAIL
Utilice SYS\$1QUERY\$1DETAIL para visualizar los detalles de las consultas en los distintos niveles de las métricas, donde cada fila representa los detalles de una consulta de WLM en un nivel de la métrica determinado. Esta vista contiene muchos tipos de consultas como DDL, DML y comandos de utilidad (por ejemplo, copiar y descargar). Según el tipo de consulta, algunas columnas pueden resultar irrelevantes. Por ejemplo, external\$1scanned\$1bytes no es relevante para las tablas internas.
SYS\$1QUERY\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
Para verificar si una transacción que contiene la consulta ejecutada se ha confirmado correctamente, debe realizar una operación de unión entre las tablas del sistema y la tabla `sys_transaction_history`. Por ejemplo:
```
SELECT
th.transaction_id,
qd.query_id,
th.status AS transaction_status
FROM
sys_query_detail qd
LEFT JOIN sys_query_history qh ON qd.query_id = qh.query_id
LEFT JOIN sys_transaction_history th on qh.transaction_id = th.transaction_id;
```
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## Notas de uso
SYS\$1QUERY\$1DETAIL puede contener métricas en el paso, la secuencia, el segmento y la consulta secundaria. Además de hacer referencia a la columna metrics\$1level, puede ver qué nivel de métrica muestra una fila determinada haciendo referencia a los campos step\$1id, segment\$1id y stream\$1id según la siguiente tabla.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_DETAIL.html)
## Consultas de ejemplo
En el siguiente ejemplo, se devuelve el resultado de SYS\$1QUERY\$1DETAIL.
La siguiente consulta muestra los detalles de metadatos de la consulta con respecto al paso, incluidos el nombre del paso, input\$1bytes, output\$1bytes, input\$1rows y output\$1rows.
```
SELECT query_id,
child_query_sequence,
stream_id,
segment_id,
step_id,
trim(step_name) AS step_name,
duration,
input_bytes,
output_bytes,
input_rows,
output_rows
FROM sys_query_detail
WHERE query_id IN (193929)
ORDER BY query_id,
stream_id,
segment_id,
step_id DESC;
```
Resultados de ejemplo.
```
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | duration | input_bytes | output_bytes | input_rows | output_rows
----------+----------------------+-----------+------------+---------+------------+-----------------+-------------+--------------+------------+-------------
193929 | 2 | 0 | 0 | 3 | hash | 37144 | 0 | 9350272 | 0 | 292196
193929 | 5 | 0 | 0 | 3 | hash | 9492 | 0 | 23360 | 0 | 1460
193929 | 1 | 0 | 0 | 3 | hash | 46809 | 0 | 9350272 | 0 | 292196
193929 | 4 | 0 | 0 | 2 | return | 7685 | 0 | 896 | 0 | 112
193929 | 1 | 0 | 0 | 2 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 2 | 0 | 0 | 2 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 2 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 2 | return | 11033 | 0 | 14336 | 0 | 112
193929 | 2 | 0 | 0 | 1 | project | 37144 | 0 | 0 | 0 | 292196
193929 | 1 | 0 | 0 | 1 | project | 46809 | 0 | 0 | 0 | 292196
193929 | 5 | 0 | 0 | 1 | project | 9492 | 0 | 0 | 0 | 1460
193929 | 3 | 0 | 0 | 1 | aggregate | 11033 | 0 | 201488 | 0 | 14
193929 | 4 | 0 | 0 | 1 | aggregate | 7685 | 0 | 28784 | 0 | 14
193929 | 5 | 0 | 0 | 0 | scan | 9492 | 0 | 23360 | 292196 | 1460
193929 | 4 | 0 | 0 | 0 | scan | 7685 | 0 | 1344 | 112 | 112
193929 | 2 | 0 | 0 | 0 | scan | 37144 | 0 | 7304900 | 292196 | 292196
193929 | 3 | 0 | 0 | 0 | scan | 11033 | 0 | 13440 | 112 | 112
193929 | 1 | 0 | 0 | 0 | scan | 46809 | 0 | 7304900 | 292196 | 292196
193929 | 5 | 0 | 0 | -1 | | 9492 | 12288 | 0 | 0 | 0
193929 | 1 | 0 | 0 | -1 | | 46809 | 16384 | 0 | 0 | 0
193929 | 2 | 0 | 0 | -1 | | 37144 | 16384 | 0 | 0 | 0
193929 | 4 | 0 | 0 | -1 | | 7685 | 28672 | 0 | 0 | 0
193929 | 3 | 0 | 0 | -1 | | 11033 | 114688 | 0 | 0 | 0
```
Para ver las tablas de la base de datos ordenadas de las más utilizadas a las menos utilizadas, utilice el siguiente ejemplo. Reemplace *sample\$1data\$1dev* con su propia base de datos. Tenga en cuenta que esta consulta contará las consultas a partir del momento en que se cree el clúster, pero los datos de visualización del sistema no se guardarán cuando no haya espacio en el almacenamiento de datos.
```
SELECT table_name, COUNT (DISTINCT query_id)
FROM SYS_QUERY_DETAIL
WHERE table_name LIKE 'sample_data_dev%'
GROUP BY table_name
ORDER BY COUNT(*) DESC;
+---------------------------------+-------+
| table_name | count |
+---------------------------------+-------+
| sample_data_dev.tickit.venue | 4 |
| sample_data_dev.myunload1.venue | 3 |
| sample_data_dev.tickit.listing | 1 |
| sample_data_dev.tickit.category | 1 |
| sample_data_dev.tickit.users | 1 |
| sample_data_dev.tickit.date | 1 |
| sample_data_dev.tickit.sales | 1 |
| sample_data_dev.tickit.event | 1 |
+---------------------------------+-------+
```
En el siguiente ejemplo, se muestran los distintos niveles de métricas de una única consulta de WLM.
```
SELECT query_id, child_query_sequence, stream_id, segment_id, step_id, step_name, start_time, end_time, metrics_level
FROM sys_query_detail
WHERE query_id = 1553 AND step_id = -1
ORDER BY stream_id, segment_id, step_id;
query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | start_time | end_time | metrics_level
----------+----------------------+-----------+------------+---------+-----------+----------------------------+----------------------------+---------------
1553 | 1 | -1 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.847838 | child query
1553 | 1 | 0 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.835609 | stream
1553 | 1 | 0 | 0 | -1 | | 2024-10-17 02:28:49.824677 | 2024-10-17 02:28:49.830372 | segment
1553 | 1 | 1 | -1 | -1 | | 2024-10-17 02:28:49.835624 | 2024-10-17 02:28:49.845773 | stream
1553 | 1 | 1 | 1 | -1 | | 2024-10-17 02:28:49.84088 | 2024-10-17 02:28:49.842388 | segment
1553 | 1 | 1 | 2 | -1 | | 2024-10-17 02:28:49.835926 | 2024-10-17 02:28:49.844396 | segment
1553 | 1 | 2 | -1 | -1 | | 2024-10-17 02:28:49.846949 | 2024-10-17 02:28:49.847838 | stream
1553 | 1 | 2 | 3 | -1 | | 2024-10-17 02:28:49.847013 | 2024-10-17 02:28:49.847485 | segment
(8 rows)
```
# SYS\$1QUERY\$1EXPLAIN
Muestra el plan EXPLAIN de una consulta que se ha enviado para ejecutarse.
SYS\$1QUERY\$1EXPLAIN es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_EXPLAIN.html)
## Consultas de ejemplo
El siguiente ejemplo es el plan EXPLAIN de una sola consulta.
```
SELECT * FROM sys_query_explain WHERE query_id = 612635 ORDER BY plan_node_id;
userid | query_id | child_query_sequence | plan_node_id | plan_parent_id | plan_node | plan_info
--------+----------+----------------------+--------------+----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
100 | 612635 | 1 | 1 | 0 | XN Limit (cost=3604047533041.00..3604047533041.25 rows=100 width=20) |
100 | 612635 | 1 | 2 | 1 | -> XN Merge (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Merge Key: sum(b.totalprice)
100 | 612635 | 1 | 3 | 2 | -> XN Network (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Send to leader
100 | 612635 | 1 | 4 | 3 | -> XN Sort (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Sort Key: sum(b.totalprice)
100 | 612635 | 1 | 5 | 4 | -> XN HashAggregate (cost=2604047529640.76..2604047529747.78 rows=42809 width=20) |
100 | 612635 | 1 | 6 | 5 | -> XN Hash Join DS_DIST_NONE (cost=15104956.16..2602364653507.34 rows=336575226684 width=20) | Hash Cond: (("outer".listid = "inner".listid) AND ("outer".sellerid = "inner".sellerid))
100 | 612635 | 1 | 7 | 6 | -> XN Seq Scan on listing b (cost=0.00..7884677.12 rows=788467712 width=24) |
100 | 612635 | 1 | 8 | 6 | -> XN Hash (cost=7063797.76..7063797.76 rows=706379776 width=8) |
100 | 612635 | 1 | 9 | 8 | -> XN Seq Scan on sales a (cost=0.00..7063797.76 rows=706379776 width=8) |
(9 rows)
```
# SYS\$1QUERY\$1HISTORY
Utilice SYS\$1QUERY\$1HISTORY para visualizar los detalles de las consultas de los usuarios. Cada una de las filas representa una consulta del usuario con estadísticas acumuladas para algunos de los campos. Esta vista contiene muchos tipos de consultas, como por ejemplo lenguaje de definición de datos (DDL), lenguaje de manipulación de datos (DML), copia, descarga y Amazon Redshift Spectrum. Contiene tanto las consultas en curso como las que han finalizado.
SYS\$1QUERY\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
**nota**
Para verificar si una transacción que contiene la consulta ejecutada se ha confirmado correctamente, debe realizar una operación de unión entre las tablas del sistema y la tabla `sys_transaction_history`. Por ejemplo:
```
SELECT
qh.transaction_id,
qh.query_id,
qh.status AS query_status,
qh.query_type,
TRIM(qh.query_text) AS query_text,
th.status AS transaction_status
FROM
sys_query_history qh
LEFT JOIN
sys_transaction_history th ON qh.transaction_id = th.transaction_id;
```
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_HISTORY.html)
## Consultas de ejemplo
La siguiente consulta devuelve consultas en ejecución y en cola.
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time
FROM sys_query_history
WHERE status IN ('running','queued')
ORDER BY start_time;
```
Resultados de ejemplo.
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time
---------+----------+----------------+------------+---------+---------------+---------------------------+----------------------------+------------------+--------------+------------+----------------
101 | 760705 | 852337 | 1073832321 | running | tpcds_1t | 2022-02-15 19:03:19.67849 | 2022-02-15 19:03:19.739811 | f | 61321 | 0 | 0
```
La siguiente consulta devuelve la hora de inicio, la hora de finalización, el tiempo en cola, el tiempo transcurrido, el tiempo de planificación y otros metadatos de una consulta específica.
```
SELECT user_id,
query_id,
transaction_id,
session_id,
status,
trim(database_name) AS database_name,
start_time,
end_time,
result_cache_hit,
elapsed_time,
queue_time,
execution_time,
planning_time,
trim(query_text) as query_text
FROM sys_query_history
WHERE query_id = 3093;
```
Resultados de ejemplo.
```
user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time | planning_time | query_text
--------+----------+----------------+------------+------------+---------------+----------------------------+----------------------------+------------------+--------------+------------+----------------+---------------+-------------------------------------
106 | 3093 | 11759 | 1073750146 | success | dev | 2023-03-16 16:53:17.840214 | 2023-03-16 16:53:18.106588 | f | 266374 | 0 | 105725 | 136589 | select count(*) from item;
```
La siguiente consulta muestra las 10 consultas SELECT más recientes.
```
SELECT query_id,
transaction_id,
session_id,
start_time,
elapsed_time,
queue_time,
execution_time,
returned_rows,
returned_bytes
FROM sys_query_history
WHERE query_type = 'SELECT'
ORDER BY start_time DESC limit 10;
```
Resultados de ejemplo.
```
query_id | transaction_id | session_id | start_time | elapsed_time | queue_time | execution_time | returned_rows | returned_bytes
----------+----------------+------------+----------------------------+--------------+------------+----------------+---------------+----------------
526532 | 61093 | 1073840313 | 2022-02-09 04:43:24.149603 | 520571 | 0 | 481293 | 1 | 3794
526520 | 60850 | 1073840313 | 2022-02-09 04:38:27.24875 | 635957 | 0 | 596601 | 1 | 3679
526508 | 60803 | 1073840313 | 2022-02-09 04:37:51.118835 | 563882 | 0 | 503135 | 5 | 17216
526505 | 60763 | 1073840313 | 2022-02-09 04:36:48.636224 | 649337 | 0 | 589823 | 1 | 652
526478 | 60730 | 1073840313 | 2022-02-09 04:36:11.741471 | 14611321 | 0 | 14544058 | 0 | 0
526467 | 60636 | 1073840313 | 2022-02-09 04:34:11.91463 | 16711367 | 0 | 16633767 | 1 | 575
511617 | 617946 | 1074009948 | 2022-01-20 06:21:54.44481 | 9937090 | 0 | 9899271 | 100 | 12500
511603 | 617941 | 1074259415 | 2022-01-20 06:21:45.71744 | 8065081 | 0 | 7582500 | 100 | 8889
511595 | 617935 | 1074128320 | 2022-01-20 06:21:44.030876 | 1051270 | 0 | 1014879 | 1 | 72
511584 | 617931 | 1074030019 | 2022-01-20 06:21:42.764088 | 609033 | 0 | 485887 | 100 | 8438
```
La siguiente consulta muestra el recuento diario de consultas select y el tiempo transcurrido promedio de consultas.
```
SELECT date_trunc('day',start_time) AS exec_day,
status,
COUNT(*) AS query_cnt,
AVG(datediff (microsecond,start_time,end_time)) AS elapsed_avg
FROM sys_query_history
WHERE query_type = 'SELECT'
AND start_time >= '2022-01-14'
AND start_time <= '2022-01-18'
GROUP BY exec_day,
status
ORDER BY exec_day,
status;
```
Resultados de ejemplo.
```
exec_day | status | query_cnt | elapsed_avg
---------------------+---------+-----------+------------
2022-01-14 00:00:00 | success | 5253 | 56608048
2022-01-15 00:00:00 | success | 7004 | 56995017
2022-01-16 00:00:00 | success | 5253 | 57016363
2022-01-17 00:00:00 | success | 5309 | 55236784
2022-01-18 00:00:00 | success | 8092 | 54355124
```
La siguiente consulta muestra el rendimiento diario de tiempo transcurrido de consulta.
```
SELECT distinct date_trunc('day',start_time) AS exec_day,
query_count.cnt AS query_count,
Percentile_cont(0.5) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P50_runtime,
Percentile_cont(0.8) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P80_runtime,
Percentile_cont(0.9) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P90_runtime,
Percentile_cont(0.99) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P99_runtime,
Percentile_cont(1.0) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS max_runtime
FROM sys_query_history
LEFT JOIN (SELECT date_trunc('day',start_time) AS day, count(*) cnt
FROM sys_query_history
WHERE query_type = 'SELECT'
GROUP by 1) query_count
ON date_trunc('day',start_time) = query_count.day
WHERE query_type = 'SELECT'
ORDER BY exec_day;
```
Resultados de ejemplo.
```
exec_day | query_count | p50_runtime | p80_runtime | p90_runtime | p99_runtime | max_runtime
---------------------+-------------+-------------+-------------+-------------+--------------+--------------
2022-01-14 00:00:00 | 5253 | 16816922.0 | 69525096.0 | 158524917.8 | 486322477.52 | 1582078873.0
2022-01-15 00:00:00 | 7004 | 15896130.5 | 71058707.0 | 164314568.9 | 500331542.07 | 1696344792.0
2022-01-16 00:00:00 | 5253 | 15750451.0 | 72037082.2 | 159513733.4 | 480372059.24 | 1594793766.0
2022-01-17 00:00:00 | 5309 | 15394513.0 | 68881393.2 | 160254700.0 | 493372245.84 | 1521758640.0
2022-01-18 00:00:00 | 8092 | 15575286.5 | 68485955.4 | 154559572.5 | 463552685.39 | 1542783444.0
2022-01-19 00:00:00 | 5860 | 16648747.0 | 72470482.6 | 166485138.2 | 492038228.67 | 1693483241.0
2022-01-20 00:00:00 | 1751 | 15422072.0 | 69686381.0 | 162315385.0 | 497066615.00 | 1439319739.0
2022-02-09 00:00:00 | 13 | 6382812.0 | 17616161.6 | 21197988.4 | 23021343.84 | 23168439.0
```
La siguiente consulta muestra la distribución de tipos de consulta.
```
SELECT query_type,
COUNT(*) AS query_count
FROM sys_query_history
GROUP BY query_type
ORDER BY query_count DESC;
```
Resultados de ejemplo.
```
query_type | query_count
------------+-------------
UTILITY | 134486
SELECT | 38537
DDL | 4832
OTHER | 768
LOAD | 768
CTAS | 748
COMMAND | 92
```
En el siguiente ejemplo, se muestra la diferencia en los resultados del hash de consulta entre varias consultas. Observe las siguientes consultas:
```
CREATE TABLE test_table (col1 INT);
INSERT INTO test_table VALUES (1),(2);
SELECT * FROM test_table;
SELECT * FROM test_table;
SELECT col1 FROM test_table;
SELECT * FROM test_table WHERE col1=1;
SELECT * FROM test_table WHERE col1=2;
SELECT query_id, TRIM(user_query_hash) AS user_query_hash, TRIM(generic_query_hash) AS generic_query_hash, TRIM(query_text) AS text FROM sys_query_history ORDER BY start_time
DESC LIMIT 10;
```
A continuación, se muestra un ejemplo de salida:
```
query_id | user_query_hash | generic_query_hash | text
---------+-----------------+--------------------+----------
24723049 | oPuFtjEPLTs= | oPuFtjEPLTs= | select query_id, trim(user_query_hash) as user_query_hash, trim(generic_query_hash) as generic_query_hash, query_hash_version, trim(query_text) as text from sys_query_history order by start_time\r\ndesc limit 20
24723045 | Gw2Kwdd8m2I= | IwfRu8/XAKI= | select * from test_table where col1=2 limit 100
24723041 | LNw2vx0GDXo= | IwfRu8/XAKI= | select * from test_table where col1=1 limit 100
24723036 | H+qep/c82Y8= | H+qep/c82Y8= | select col1 from test_table limit 100
24723033 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723029 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100
24723023 | 50sirx9E1hU= | uO36Z1a/QYs= | insert into test_table values (1),(2)
24723021 | YSVnlivZHeo= | YSVnlivZHeo= | create table test_table (col1 int)
```
`SELECT * FROM test_table;` y `SELECT col1 FROM test_table;` tienen el mismo valor de user\$1query\$1hash, ya que test\$1table solo tiene una columna. `SELECT * FROM test_table WHERE col1=1;` y `SELECT * FROM test_table WHERE col1=2;` tienen valores de user\$1query\$1hash diferentes, pero valores de generic\$1query\$1hash idénticos, ya que las dos consultas son idénticas fuera de los literales de consulta 1 y 2.
# SYS\$1QUERY\$1TEXT
Utilice SYS\$1QUERY\$1TEXT para ver el texto de todas las consultas. Cada fila representa el texto de las consultas de hasta 4000 caracteres que comienzan por el número de secuencia 0. Cuando la instrucción de consulta contiene más de 4000 caracteres, se registran filas adicionales para la instrucción al incrementar el número de secuencia de cada fila. Esta vista registra todo el texto de las consultas de los usuarios como las consultas de DDL, de utilidades, de Amazon Redshift y únicas del nodo principal.
SYS\$1QUERY\$1TEXT es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_TEXT.html)
## Consultas de ejemplo
La siguiente consulta devuelve consultas en ejecución y en cola.
```
SELECT user_id,
query_id,
transaction_id,
session_id, start_time,
sequence, trim(text) as text from sys_query_text
ORDER BY sequence;
```
Resultados de ejemplo.
```
user_id | query_id | transaction_id | session_id | start_time | sequence | text
--------+----------+-----------------+------------+----------------------------+----------+----------------------------------------------------------------------------------------------------------------------
100 | 4 | 1396 | 1073750220 | 2023-04-28 16:44:55.887184 | 0 | SELECT trim(text) as text, sequence FROM sys_query_text WHERE query_id = pg_last_query_id() AND user_id > 1 AND start
_time > '2023-04-28 16:44:55.922705+00:00'::timestamp order by sequence;
```
La siguiente consulta devuelve los permisos concedidos o revocados a los grupos de la base de datos.
```
SELECT
SPLIT_PART(text, ' ', 1) as grantrevoke,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'GROUP'))), ' ', 2) as group,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), ' '))), 'ON', 1) as type,
SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 2) || ' ' || SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 3) as entity
FROM SYS_QUERY_TEXT
WHERE (text LIKE 'GRANT%' OR text LIKE 'REVOKE%') AND text LIKE '%GROUP%';
+-------------+----------+--------+----------+
| grantrevoke | group | type | entity |
+-------------+----------+--------+----------+
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | USAGE | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
| GRANT | bi_group | SELECT | TABLE t1 |
+-------------+----------+--------+----------+
```
# SYS\$1REDSHIFT\$1TEMPLATE
Utilice SYS\$1REDSHIFT\$1TEMPLATE para ver los detalles de Redshift TEMPLATES.
Esta vista contiene las TEMPLATES que se han creado.
SYS\$1REDSHIFT\$1TEMPLATE es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_REDSHIFT_TEMPLATE.html)
## Consultas de ejemplo
La siguiente consulta devuelve todas las plantillas visibles para el usuario actual:
```
SELECT * FROM SYS_REDSHIFT_TEMPLATE;
```
Resultados de ejemplo.
```
database_name | schema_name | template_name | template_type | create_time | last_modified_time | owner_id | last_modified_by | template_parameters
---------------+-------------+--------------------+---------------+----------------------------+----------------------------+----------+------------------+---------------------
dev | s1 | shapefile_template | 1 | 2025-12-17 22:42:02.079758 | 2025-12-17 22:42:02.079758 | 101 | 101 | {
"SIMPLIFY_AUTO": 0.000001,
"SHAPEFILE": 1,
"COMPRESSION_UPDATE": 0
}
dev | s2 | orc_template | 1 | 2025-12-17 22:42:23.582815 | 2025-12-17 22:42:23.582815 | 101 | 101 | {
"ORC": "serializetojson_default"
}
dev | s1 | csv_template | 1 | 2025-12-17 22:43:01.822361 | 2025-12-17 22:43:01.822361 | 101 | 101 | {
"ENCRYPTED": 1,
"CSV": 1,
"ENCODING": 1,
"DELIMITER": ","
}
(3 rows)
```
# SYS\$1RESTORE\$1LOG
Utilice SYS\$1RESTORE\$1LOG para monitorear la evolución de la migración de cada tabla del clúster durante un cambio de tamaño clásico hacia los nodos RA3. Captura el rendimiento histórico de la migración de datos durante la operación de cambio de tamaño. Para obtener más información sobre el cambio de tamaño clásico hacia los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster).
SYS\$1RESTORE\$1STATE solo es visible para los superusuarios.
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_RESTORE_LOG.html)
## Consultas de ejemplo
La siguiente consulta calcula el rendimiento del procesamiento de datos mediante SYS\$1RESTORE\$1LOG.
```
SELECT
ROUND(sum(delta_data_processed) / 1024.0, 2) as data_processed_gb,
ROUND(datediff(sec, min(event_time), max(event_time)) / 3600.0, 2) as duration_hr,
ROUND(data_processed_gb/duration_hr, 2) as throughput_gb_per_hr
from sys_restore_log;
```
Resultados de ejemplo.
```
data_processed_gb | duration_hr | throughput_gb_per_hr
-------------------+-------------+----------------------
0.91 | 8.37 | 0.11
(1 row)
```
La siguiente consulta muestra todos los tipos de redistribución.
```
SELECT * from sys_restore_log ORDER BY event_time;
```
```
database_name | schema_name | table_name | table_id | action | total_data_processed | delta_data_processed | event_time | table_size | message | redistribution_type
---------------+----------------------+----------------------+----------+-----------------------------+----------------------+----------------------+----------------------------+------------+---------+--------------------------
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution started | 0 | | 2024-01-05 02:18:00.744977 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution started | 0 | | 2024-01-05 02:18:02.756675 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution completed | 90 | 90 | 2024-01-05 02:23:30.643718 | 90 | | Restore Distkey Table
dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution completed | 325 | 325 | 2024-01-05 02:23:45.998249 | 325 | | Restore Distkey Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution started | 0 | | 2024-01-05 02:23:46.083849 | 30 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution started | 0 | | 2024-01-05 02:23:46.855728 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution completed | 45 | 45 | 2024-01-05 02:24:16.343029 | 45 | | Rebalance Disteven Table
dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution completed | 30 | 30 | 2024-01-05 02:24:20.584703 | 30 | | Rebalance Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution started | 0 | | 2024-01-05 04:54:55.641741 | 190 | | Restore Disteven Table
dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution checkpointed | 29.4342113157737 | 29.4342113157737 | 2024-01-05 04:55:04.770696 | 190 | | Restore Disteven Table
(8 rows)
```
# SYS\$1RESTORE\$1STATE
Utilice SYS\$1RESTORE\$1STATE para monitorear la evolución de la migración de cada tabla durante un cambio de tamaño clásico. Esto es aplicable específicamente cuando el tipo de nodo de destino es RA3. Para obtener más información sobre el cambio de tamaño clásico hacia los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster).
SYS\$1RESTORE\$1STATE solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_RESTORE_STATE.html)
## Consultas de ejemplo
La siguiente consulta devuelve los registros para las consultas en ejecución y en cola.
```
SELECT * FROM sys_restore_state;
```
Resultados de ejemplo.
```
userid | database_name | schema_id | table_id | table_name | redistribution_status | precentage_redistributed | redistribution_type
--------+---------------+-----------+----------+----------------+-----------------------+--------------------------+-------------------------
1 | test1 | 124865 | 124878 | customer_key_4 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124874 | customer_key_3 | Pending | 0 | Rebalance Disteven Table
1 | dev | 124865 | 124870 | customer_key_2 | Completed | 100 | Rebalance Disteven Table
1 | dev | 124865 | 124866 | customer_key_1 | In progress | 13.52 | Restore Distkey Table
```
A continuación se muestra el estado del procesamiento de datos.
```
SELECT
redistribution_status, ROUND(SUM(block_count) / 1024.0, 2) AS total_size_gb
FROM sys_restore_state sys inner join stv_tbl_perm stv
on sys.table_id = stv.id
GROUP BY sys.redistribution_status;
```
Resultados de ejemplo.
```
redistribution_status | total_size_gb
-----------------------+---------------
Completed | 0.07
Pending | 0.71
In progress | 0.20
(3 rows)
```
# SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS
Registra la incidencia, marca temporal, ID y otros datos útiles cuando se excede una cuota de esquema. Esta tabla del sistema es una traducción de [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md).
r\$1SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_SCHEMA_QUOTA_VIOLATIONS.html)
## Consultas de ejemplo
En la siguiente consulta se muestra el resultado de la infracción de cuota:
```
SELECT user_id, TRIM(schema_name) "schema_name", quota, disk_usage, record_time FROM
sys_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC;
```
Esta consulta devuelve el siguiente resultado de ejemplo para el esquema especificado:
```
user_id| schema_name | quota | disk_usage | record_time
-------+--------------+-------+------------+----------------------------
104 | sales_schema | 2048 | 2798 | 2020-04-20 20:09:25.494723
(1 row)
```
# SYS\$1SERVERLESS\$1USAGE
Utilice SYS\$1SERVERLESS\$1USAGE para ver los detalles del uso de los recursos de Amazon Redshift sin servidor. Esta vista del sistema no se aplica a los clústeres aprovisionados de Amazon Redshift.
Esta vista contiene el resumen de uso sin servidor, incluidas la capacidad de computación utilizada para procesar consultas y la cantidad de almacenamiento administrado de Amazon Redshift que se utiliza con una precisión de 1 minuto. La capacidad de computación se mide en unidades de procesamiento Redshift (RPU) y se dosifica para las cargas de trabajo que se ejecutan en RPU por segundo. Las RPU se utilizan para procesar consultas sobre los datos cargados en el almacenamiento de datos, que se consultan desde un lago de datos de Amazon S3 o a los que se obtiene acceso desde las bases de datos operativas mediante una consulta federada. Amazon Redshift sin servidor conserva la información en SYS\$1SERVERLESS\$1USAGE durante 7 días.
Para ver ejemplos de facturación de costos de computación, consulte [Facturación de Amazon Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html).
SYS\$1SERVERLESS\$1USAGE es visible para todos los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SERVERLESS_USAGE.html)
## Notas de uso
+ Hay situaciones en las que compute\$1seconds es 0 pero charged\$1seconds es mayor que 0 o viceversa. Este es un comportamiento normal debido a la forma en que se graban los datos en la vista del sistema. Para obtener una representación más precisa de los detalles del uso sin servidor, recomendamos agregar los datos.
## Ejemplo
Para obtener el total de cargos por horas de RPU utilizadas durante un intervalo de tiempo mediante la consulta charged\$1seconds, ejecute la siguiente consulta:
```
select trunc(start_time) "Day",
(sum(charged_seconds)/3600::double precision) * as cost_incurred
from sys_serverless_usage
group by 1
order by 1
```
Tenga en cuenta que puede haber tiempo de inactividad durante el intervalo. El tiempo inactivo no se suma a las RPU consumidas.
# SYS\$1SESSION\$1HISTORY
Utilice SYS\$1SESSION\$1HISTORY para ver información sobre las sesiones activas actuales y el historial de sesiones.
SYS\$1SESSION\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SESSION_HISTORY.html)
### Ejemplo
A continuación se muestra un ejemplo de salida de SYS\$1SESSION\$1HISTORY.
```
select * from sys_session_history;
user_id | session_id | database_name | status | session_timeout | start_time | end_time
---------+------------+------------------+--------+-----------------+----------------------------+----------------------------
1 | 1073971370 | dev | closed | 0 | 2023-07-17 15:50:12.030104 | 2023-07-17 15:50:12.123218
1 | 1073979694 | dev | closed | 0 | 2023-07-17 15:50:24.117947 | 2023-07-17 15:50:24.131859
1 | 1073873049 | dev | closed | 0 | 2023-07-17 15:49:29.067398 | 2023-07-17 15:49:29.070294
1 | 1073873086 | database18127a4a | closed | 0 | 2023-07-17 15:49:29.119018 | 2023-07-17 15:49:29.125925
1 | 1073832112 | dev | closed | 0 | 2023-07-17 15:49:29.164688 | 2023-07-17 15:49:29.179631
1 | 1073987697 | dev | closed | 0 | 2023-07-17 15:49:29.26749 | 2023-07-17 15:49:29.273034
1 | 1073922429 | dev | closed | 0 | 2023-07-17 15:49:33.35315 | 2023-07-17 15:49:33.367499
1 | 1073766783 | dev | closed | 0 | 2023-07-17 15:49:45.38237 | 2023-07-17 15:49:45.396902
1 | 1073807506 | dev | active | 0 | 2023-07-17 15:51:48 |
```
# SYS\$1SPATIAL\$1SIMPLIFY
Puede consultar la vista del sistema SYS\$1SPATIAL\$1SIMPLIFY para obtener información acerca de los objetos de geometría espacial simplificada mediante el comando COPY. Cuando utiliza COPY en un shapefile, puede especificar las opciones de ingesta SIMPLIFY `tolerance`, SIMPLIFY AUTO y SIMPLIFY AUTO `max_tolerance`. El resultado de la simplificación se resume en la vista de sistema SYS\$1SPATIAL\$1SIMPLIFY.
Cuando se configura SIMPLIFY AUTO `max_tolerance`, esta vista contiene una fila para cada geometría que excedió el tamaño máximo. Cuando se configura SIMPLIFY `tolerance`, se almacena una fila para toda la operación COPY. Esta fila referencia el ID de consulta COPY y la tolerancia de simplificación especificada.
Para obtener más información sobre cómo cargar un shapefile, consulte [Carga de un shapefile en Amazon Redshift](spatial-copy-shapefile.md).
SYS\$1SPATIAL\$1SIMPLIFY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SPATIAL_SIMPLIFY.html)
## Consulta de ejemplo
La siguiente consulta devuelve la lista de registros que COPY simplificó.
```
SELECT * FROM sys_spatial_simplify;
query_id | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
----------+-------------+-------------------+--------------+------------+------------+----------------------
20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05
20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06
```
# SYS\$1STREAM\$1SCAN\$1ERRORS
Registra los errores de los registros cargados mediante la ingesta de streaming.
SYS\$1STREAM\$1SCAN\$1ERRORS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html)
# SYS\$1STREAM\$1SCAN\$1STATES
Registra los estados de exploración de los registros cargados mediante la ingesta de streaming.
SYS\$1STREAM\$1SCAN\$1STATES es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_STREAM_SCAN_STATES.html)
En la siguiente consulta se muestran los datos de flujo y de tema para consultas específicas.
```
select query_id,mv_name::varchar,external_schema_name::varchar,stream_name::varchar,sum(scanned_rows) total_records,
sum(scanned_bytes) total_bytes from sys_stream_scan_states where query in (5401180,8601939) group by 1,2,3,4;
query_id | mv_name | external_schema_name | stream_name | total_records | total_bytes
------------+----------------+----------------------+-----------------+---------------+----------------
5401180 | kinesistest | kinesis | kinesisstream | 1493255696 | 3209006490704
8601939 | msktest | msk | mskstream | 14677023 | 31056580668
(2 rows)
```
# SYS\$1TRANSACTION\$1HISTORY
Utilice SYS\$1TRANSACTION\$1HISTORY para ver los detalles de una transacción al realizar el seguimiento de una consulta.
SYS\$1TRANSACTION\$1HISTORY solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_TRANSACTION_HISTORY.html)
## Consultas de ejemplo
```
select * from sys_transaction_history order by transaction_start_time desc;
user_id | transaction_id | isolation_level | status | transaction_start_time | commit_start_time | commit_end_time | blocks_committed | undo_transaction_id
---------+----------------+-----------------+------------+----------------------------+----------------------------+----------------------------+------------------+---------------------
100 | 1310 | Serializable | committed | 2023-08-27 21:03:11.822205 | 2023-08-28 21:03:11.825287 | 2023-08-28 21:03:11.854883 | 17 | -1
101 | 1345 | Serializable | committed | 2023-08-27 21:03:12.000278 | 2023-08-28 21:03:12.003736 | 2023-08-28 21:03:12.030061 | 17 | -1
102 | 1367 | Serializable | committed | 2023-08-27 21:03:12.1532 | 2023-08-28 21:03:12.156124 | 2023-08-28 21:03:12.186468 | 17 | -1
100 | 1370 | Serializable | committed | 2023-08-27 21:03:12.199316 | 2023-08-28 21:03:12.204854 | 2023-08-28 21:03:12.238186 | 24 | -1
100 | 1408 | Serializable | committed | 2023-08-27 21:03:53.891107 | 2023-08-28 21:03:53.894825 | 2023-08-28 21:03:53.927465 | 17 | -1
100 | 1409 | Serializable | rolledback | 2023-08-27 21:03:53.936431 | 2000-01-01 00:00:00 | 2023-08-28 21:04:08.712532 | 0 | 1409
101 | 1415 | Serializable | committed | 2023-08-27 21:04:24.283188 | 2023-08-28 21:04:24.289196 | 2023-08-28 21:04:24.374318 | 25 | -1
101 | 1416 | Serializable | committed | 2023-08-27 21:04:24.38818 | 2023-08-28 21:04:24.391688 | 2023-08-28 21:04:24.415135 | 17 | -1
100 | 1417 | Serializable | rolledback | 2023-08-27 21:04:24.424252 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.354826 | 0 | 1417
101 | 1418 | Serializable | rolledback | 2023-08-27 21:04:24.425195 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.680355 | 0 | 1418
100 | 1420 | Serializable | committed | 2023-08-27 21:04:28.697607 | 2023-08-28 21:04:28.702374 | 2023-08-28 21:04:28.735541 | 23 | -1
101 | 1421 | Serializable | committed | 2023-08-27 21:04:28.744854 | 2023-08-28 21:04:28.749344 | 2023-08-28 21:04:28.779029 | 23 | -1
101 | 1423 | Serializable | committed | 2023-08-27 21:04:28.78942 | 2023-08-28 21:04:28.791556 | 2023-08-28 21:04:28.817485 | 16 | -1
100 | 1430 | Serializable | committed | 2023-08-27 21:04:28.917788 | 2023-08-28 21:04:28.919993 | 2023-08-28 21:04:28.944812 | 16 | -1
102 | 1494 | Serializable | committed | 2023-08-27 21:04:37.029058 | 2023-08-28 21:04:37.033137 | 2023-08-28 21:04:37.062001 | 16 | -1
```
# SYS\$1UDF\$1LOG
Registra los mensajes de error y advertencia definidos por el sistema generados durante la ejecución de la función definida por el usuario (UDF).
SYS\$1UDF\$1LOG solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UDF_LOG.html)
## Consultas de ejemplo
En el siguiente ejemplo, se muestra cómo las UDF administran los errores definidos por el sistema. El primer bloque muestra la definición para una función UDF que devuelve la inversa de un argumento. Si ejecuta la función y proporciona un 0 como argumento, la función devuelve un error. La última instrucción devuelve el mensaje de error registrado en SYS\$1UDF\$1LOG.
```
-- Create a function to find the inverse of a number.
CREATE OR REPLACE FUNCTION f_udf_inv(a int)
RETURNS float
IMMUTABLE AS $$return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to create an error.
Select f_udf_inv(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------
2211 | 2023-08-23 15:53:11.360538 | ZeroDivisionError: integer division or modulo by zero line 2, in f_udf_inv\n return 1/a\n
```
En el siguiente ejemplo, se agrega el registro y un mensaje de advertencia a la UDF para que una operación de división en cero dé como resultado un mensaje de advertencia, en lugar de parar con un mensaje de error.
```
-- Create a function to find the inverse of a number and log a warning if you input 0.
CREATE OR REPLACE FUNCTION f_udf_inv_log(a int)
RETURNS float IMMUTABLE
AS $$
import logging
logger = logging.getLogger() #get root logger
if a==0:
logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n')
return 0
else:
return 1/a
$$ LANGUAGE plpythonu;
-- Run the function with 0 to trigger the warning.
Select f_udf_inv_log(0);
-- Query SYS_UDF_LOG to view the message.
Select query_id, record_time, message::varchar from sys_udf_log;
query_id | record_time | message
----------+----------------------------+-------------------------------------------------------------------------------
0 | 2023-08-23 16:10:48.833503 | WARNING: You attempted to divide by zero.\nReturning zero instead of error.\n
```
# SYS\$1UNLOAD\$1DETAIL
Utilice SYS\$1UNLOAD\$1TAIL para ver los detalles de la operación UNLOAD. Registra una fila por cada archivo creado por una instrucción UNLOAD. Por ejemplo, si una instrucción UNLOAD crea 12 archivos, SYS\$1UNLOAD\$1DETAIL contendrá 12 filas correspondientes.
SYS\$1UNLOAD\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UNLOAD_DETAIL.html)
## Consultas de ejemplo
La siguiente consulta muestra los detalles de la consulta descargada, incluidos el formato, las filas y el recuento de archivos del comando unload.
```
select query_id, substring(file_name, 0, 50), transfer_size, file_format from sys_unload_detail;
```
Resultados de ejemplo.
```
query_id | substring | transfer_size | file_format
----------+-------------------------------------------------------------+---------------+-------------
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0000_part_00.gz | 395886 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0001_part_00.gz | 406444 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0002_part_00.gz | 409431 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0003_part_00.gz | 403051 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0004_part_00.gz | 413592 | Text
9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0005_part_00.gz | 395689 | Text
(6 rows)
```
# SYS\$1UNLOAD\$1HISTORY
Utilice SYS\$1UNLOAD\$1HISTORY para visualizar los detalles de los comandos UNLOAD. Cada una de las filas representa un comando UNLOAD con estadísticas acumuladas para algunos de los campos. Contiene tanto los comandos UNLOAD en ejecución como los que han finalizado.
SYS\$1UNLOAD\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UNLOAD_HISTORY.html)
## Consultas de ejemplo
La siguiente consulta muestra los detalles de la consulta descargada, incluidos el formato, las filas y el recuento de archivos del comando unload.
```
SELECT query_id,
file_format,
start_time,
duration,
unloaded_rows,
unloaded_files_count
FROM sys_unload_history
ORDER BY query_id,
file_format limit 100;
```
Resultados de ejemplo.
```
query_id | file_format | start_time | duration | unloaded_rows | unloaded_files_count
----------+-------------+----------------------------+----------+---------------+----------------------
527067 | Text | 2022-02-09 05:18:35.844452 | 5932478 | 10 | 1
```
# SYS\$1USERLOG
Registra detalles de los siguientes cambios realizados en un usuario de una base de datos:
+ Creación de usuario
+ Eliminación de usuario
+ Modificación de usuario (cambio de nombre)
+ Modificación de usuario (modificación de propiedades)
Puede consultar esta vista para obtener información sobre los grupos de trabajo sin servidor y los clústeres aprovisionados.
SYS\$1USERLOG solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_USERLOG.html)
## Consultas de ejemplo
En el siguiente ejemplo, se realizan cuatro acciones del usuario y, luego, se consulta la vista SYS\$1USERLOG.
```
CREATE USER userlog1 password 'Userlog1';
ALTER USER userlog1 createdb createuser;
ALTER USER userlog1 rename to userlog2;
DROP user userlog2;
SELECT user_id, user_name, original_user_name, action, has_create_db_privs, is_superuser from SYS_USERLOG order by record_time desc;
```
```
user_id | user_name | original_user_name | action | has_create_db_privs | is_superuser
--------+------------+--------------------+---------+---------------------+------------
108 | userlog2 | | drop | 1 | 1
108 | userlog2 | userlog1 | rename | 1 | 1
108 | userlog1 | | alter | 1 | 1
108 | userlog1 | | create | 0 | 0
(4 rows)
```
# SYS\$1VACUUM\$1HISTORY
Utilice SYS\$1VACUUM\$1HISTORY para visualizar los detalles de las consultas de los usuarios. Para obtener información sobre el comando VACUUM, consulte [VACUUM](r_VACUUM_command.md).
SYS\$1VACUUM\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data).
## Columnas de la tabla
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_VACUUM_HISTORY.html)