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 STL para registro Las vistas de sistema STL se generan a partir de archivos de registro de Amazon Redshift para proporcionar un historial del sistema. Estos archivos residen en cada uno de los nodos del clúster en el data warehouse. Las vistas STL toman la información de los registros y les dan el formato de vistas, que pueden utilizar los administradores del sistema. **Retención de registros**: las vistas del sistema STL retienen siete días del historial de registros. La retención de registros está garantizada para todos los tamaños y tipos de nodos de clústeres y no se ve afectada por los cambios en la carga de trabajo del clúster. La retención de registros tampoco se ve afectada por el estado del clúster, como cuando el clúster está en pausa. Tiene menos de siete días de historial de registros solo en el caso de que el clúster sea nuevo. No necesita ninguna acción para retener registros, pero deberá copiar periódicamente los datos de registros en otras tablas o descargarlos en Amazon S3 para conservar los datos de registros con más de siete días de antigüedad. **Topics** + [STL\$1AGGR](r_STL_AGGR.md) + [STL\$1ALERT\$1EVENT\$1LOG](r_STL_ALERT_EVENT_LOG.md) + [STL\$1ANALYZE](r_STL_ANALYZE.md) + [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md) + [STL\$1BCAST](r_STL_BCAST.md) + [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md) + [STL\$1CONNECTION\$1LOG](r_STL_CONNECTION_LOG.md) + [STL\$1DDLTEXT](r_STL_DDLTEXT.md) + [STL\$1DELETE](r_STL_DELETE.md) + [STL\$1DISK\$1FULL\$1DIAG](r_STL_DISK_FULL_DIAG.md) + [STL\$1DIST](r_STL_DIST.md) + [STL\$1ERROR](r_STL_ERROR.md) + [STL\$1EXPLAIN](r_STL_EXPLAIN.md) + [STL\$1FILE\$1SCAN](r_STL_FILE_SCAN.md) + [STL\$1HASH](r_STL_HASH.md) + [STL\$1HASHJOIN](r_STL_HASHJOIN.md) + [STL\$1INSERT](r_STL_INSERT.md) + [STL\$1LIMIT](r_STL_LIMIT.md) + [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md) + [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) + [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md) + [STL\$1MERGE](r_STL_MERGE.md) + [STL\$1MERGEJOIN](r_STL_MERGEJOIN.md) + [STL\$1MV\$1STATE](r_STL_MV_STATE.md) + [STL\$1NESTLOOP](r_STL_NESTLOOP.md) + [STL\$1PARSE](r_STL_PARSE.md) + [STL\$1PLAN\$1INFO](r_STL_PLAN_INFO.md) + [STL\$1PROJECT](r_STL_PROJECT.md) + [STL\$1QUERY](r_STL_QUERY.md) + [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) + [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) + [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) + [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md) + [STL\$1RETURN](r_STL_RETURN.md) + [STL\$1S3CLIENT](r_STL_S3CLIENT.md) + [STL\$1S3CLIENT\$1ERROR](r_STL_S3CLIENT_ERROR.md) + [STL\$1SAVE](r_STL_SAVE.md) + [STL\$1SCAN](r_STL_SCAN.md) + [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md) + [STL\$1SESSIONS](r_STL_SESSIONS.md) + [STL\$1SORT](r_STL_SORT.md) + [STL\$1SSHCLIENT\$1ERROR](r_STL_SSHCLIENT_ERROR.md) + [STL\$1STREAM\$1SEGS](r_STL_STREAM_SEGS.md) + [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md) + [STL\$1UNDONE](r_STL_UNDONE.md) + [STL\$1UNIQUE](r_STL_UNIQUE.md) + [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md) + [STL\$1USAGE\$1CONTROL](r_STL_USAGE_CONTROL.md) + [STL\$1USERLOG](r_STL_USERLOG.md) + [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) + [STL\$1VACUUM](r_STL_VACUUM.md) + [STL\$1WINDOW](r_STL_WINDOW.md) + [STL\$1WLM\$1ERROR](r_STL_WLM_ERROR.md) + [STL\$1WLM\$1RULE\$1ACTION](r_STL_WLM_RULE_ACTION.md) + [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md) # STL\$1AGGR Analiza los pasos de ejecución de agregación de las consultas. Estos pasos tienen lugar durante la ejecución de las funciones de agregación y de las cláusulas GROUP BY. STL\$1AGGR 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** STL\$1AGGR solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_AGGR.html) ## Consultas de ejemplo Devuelve información acerca de los pasos de ejecución de agregación para SLICE 1 y TBL 239. ``` select query, segment, bytes, slots, occupied, maxlength, is_diskbased, workmem, type from stl_aggr where slice=1 and tbl=239 order by rows limit 10; ``` ``` query | segment | bytes | slots | occupied | maxlength | is_diskbased | workmem | type -------+---------+-------+---------+----------+-----------+--------------+-----------+-------- 562 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED 616 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED 546 | 1 | 0 | 4194304 | 0 | 0 | f | 383385600 | HASHED 547 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN 685 | 1 | 32 | 4194304 | 1 | 0 | f | 383385600 | HASHED 652 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN 680 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN 658 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN 686 | 0 | 8 | 0 | 0 | 0 | f | 0 | PLAIN 695 | 1 | 32 | 4194304 | 1 | 0 | f | 383385600 | HASHED (10 rows) ``` # STL\$1ALERT\$1EVENT\$1LOG Registra una alerta cuando el optimizador de consultas identifica condiciones que podrían indicar problemas de rendimiento. Utilice la vista STL\$1ALERT\$1EVENT\$1LOG para identificar oportunidades de mejora del rendimiento de las consultas. Una consulta consta de distintos segmentos y cada segmento consta de uno o más pasos. Para obtener más información, consulte [Procesamiento de consultas](c-query-processing.md). STL\$1ALERT\$1EVENT\$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). **nota** STL\$1ALERT\$1EVENT\$1LOG solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_ALERT_EVENT_LOG.html) ## Notas de uso Puede utilizar STL\$1ALERT\$1EVENT\$1LOG para identificar posibles problemas en sus consultas; luego, siga las prácticas descritas en [‎‎‎‎Ajuste del rendimiento de las consul‎tas](c-optimizing-query-performance.md) para optimizar el diseño de su base de datos y vuelva a escribir sus consultas. STL\$1ALERT\$1EVENT\$1LOG registra las siguientes alertas: + **Faltan estadísticas** Faltan estadísticas. Ejecute la función ANALYZE después de la carga de datos o de actualizaciones importantes y utilice la función STATUPDATE con las operaciones COPY. Para obtener más información, consulte [Prácticas recomendadas de Amazon Redshift para el diseño de consultas](c_designing-queries-best-practices.md). + **Bucle anidado ** Un bucle anidado es, por lo general, un producto cartesiano. Evalúe su consulta para asegurarse de que todas las tablas que emplee estén combinadas de forma eficaz. + **Filtro muy selectivo** La relación de filas devueltas respecto a las filas examinadas es inferior al 0,05. Las filas examinadas es el valor de `rows_pre_user_filter` y las filas devueltas es el valor de las filas de la vista de sistema [STL\$1SCAN](r_STL_SCAN.md). Indica que la consulta está examinando una cantidad excepcionalmente grande de filas para determinar el conjunto de resultados. Esto puede deberse a que faltan claves de ordenación, o que estas son incorrectas. Para obtener más información, consulte [Claves de clasificación](t_Sorting_data.md). + **Filas fantasma excesivas ** Un examen omitió una cantidad considerablemente grande de filas que están marcadas como eliminadas pero no limpiadas o filas que fueron insertadas pero no confirmadas. Para obtener más información, consulte [Limpieza de tablas](t_Reclaiming_storage_space202.md). + **Distribución grande ** Más de 1 000 000 filas fueron redistribuidas para una combinación hash o una agregación. Para obtener más información, consulte [Distribución de datos para la optimización de consultas](t_Distributing_data.md). + **Difusión grande ** Más de 1 000 000 filas fueron difundidas para una combinación hash. Para obtener más información, consulte [Distribución de datos para la optimización de consultas](t_Distributing_data.md). + **Ejecución en serie ** En el plan de consulta se indicó un estilo de redistribución DS\$1DIST\$1ALL\$1INNER, lo que exige una ejecución en serie porque toda la tabla interna fue redistribuida a un nodo único. Para obtener más información, consulte [Distribución de datos para la optimización de consultas](t_Distributing_data.md). ## Consultas de ejemplo La siguiente consulta muestra eventos de alerta para cuatro consultas. ``` SELECT query, substring(event,0,25) as event, substring(solution,0,25) as solution, trim(event_time) as event_time from stl_alert_event_log order by query; query | event | solution | event_time -------+-------------------------------+------------------------------+--------------------- 6567 | Missing query planner statist | Run the ANALYZE command | 2014-01-03 18:20:58 7450 | Scanned a large number of del | Run the VACUUM command to rec| 2014-01-03 21:19:31 8406 | Nested Loop Join in the query | Review the join predicates to| 2014-01-04 00:34:22 29512 | Very selective query filter:r | Review the choice of sort key| 2014-01-06 22:00:00 (4 rows) ``` # STL\$1ANALYZE Registra detalles para las operaciones [ANALYZE](r_ANALYZE.md). SYS\$1ANALYZE 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_ANALYZE.html) ## Consultas de ejemplo En el siguiente ejemplo, se combina STV\$1TBL\$1PERM para mostrar el nombre de la tabla y los detalles de ejecución. ``` select distinct a.xid, trim(t.name) as name, a.status, a.rows, a.modified_rows, a.starttime, a.endtime from stl_analyze a join stv_tbl_perm t on t.id=a.table_id where name = 'users' order by starttime; xid | name | status | rows | modified_rows | starttime | endtime -------+-------+-----------------+-------+---------------+---------------------+-------------------- 1582 | users | Full | 49990 | 49990 | 2016-09-22 22:02:23 | 2016-09-22 22:02:28 244287 | users | Full | 24992 | 74988 | 2016-10-04 22:50:58 | 2016-10-04 22:51:01 244712 | users | Full | 49984 | 24992 | 2016-10-04 22:56:07 | 2016-10-04 22:56:07 245071 | users | Skipped | 49984 | 0 | 2016-10-04 22:58:17 | 2016-10-04 22:58:17 245439 | users | Skipped | 49984 | 1982 | 2016-10-04 23:00:13 | 2016-10-04 23:00:13 (5 rows) ``` # STL\$1ANALYZE\$1COMPRESSION Registra detalles para las operaciones de análisis de compresión durante los comandos COPY o ANALYZE COMPRESSION. SYS\$1ANALYZE\$1COMPRESSION 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_ANALYZE_COMPRESSION.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 xid, tbl, btrim(tablename) as tablename, col, old_encoding, new_encoding, best_compression_encoding, mode from stl_analyze_compression where xid = (select xid from stl_query where query = pg_last_copy_id()) order by col; xid | tbl | tablename | col | old_encoding | new_encoding | best_compression_encoding | mode ------+--------+-----------+-----+-----------------+-----------------+---------------------------+---------------- 5308 | 158961 | $lineitem | 0 | mostly32 | az64 | delta | ON 5308 | 158961 | $lineitem | 1 | mostly32 | az64 | az64 | ON 5308 | 158961 | $lineitem | 2 | lzo | az64 | az64 | ON 5308 | 158961 | $lineitem | 3 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 4 | bytedict | az64 | bytedict | ON 5308 | 158961 | $lineitem | 5 | mostly32 | az64 | az64 | ON 5308 | 158961 | $lineitem | 6 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 7 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 8 | lzo | lzo | lzo | ON 5308 | 158961 | $lineitem | 9 | runlength | runlength | runlength | ON 5308 | 158961 | $lineitem | 10 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 11 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 12 | delta | az64 | az64 | ON 5308 | 158961 | $lineitem | 13 | bytedict | bytedict | bytedict | ON 5308 | 158961 | $lineitem | 14 | bytedict | bytedict | bytedict | ON 5308 | 158961 | $lineitem | 15 | text255 | text255 | text255 | ON (16 rows) ``` # STL\$1BCAST Registra información acerca de la actividad de red durante la ejecución de los pasos de la consulta que difunden datos. Los números de filas, bytes y paquetes que se envían por la red durante un paso determinado en un sector determinado capturan el tráfico de red. La duración del paso es la diferencia entre la hora de inicio y de finalización del registro. Para identificar los pasos de difusión en una consulta, busque las etiquetas bcast en la vista SVL\$1QUERY\$1SUMMARY o ejecute el comando EXPLAIN y, luego, busque atributos del paso que incluyan la etiqueta bcast. STL\$1BCAST 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** STL\$1BCAST solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_BCAST.html) ### Consultas de ejemplo El siguiente ejemplo devuelve información de difusión para las consultas donde hay uno o más paquetes, y la diferencia entre el inicio y la finalización de la consulta fue de un segundo o más. ``` select query, slice, step, rows, bytes, packets, datediff(seconds, starttime, endtime) from stl_bcast where packets>0 and datediff(seconds, starttime, endtime)>0; ``` ``` query | slice | step | rows | bytes | packets | date_diff -------+-------+------+------+-------+---------+----------- 453 | 2 | 5 | 1 | 264 | 1 | 1 798 | 2 | 5 | 1 | 264 | 1 | 1 1408 | 2 | 5 | 1 | 264 | 1 | 1 2993 | 0 | 5 | 1 | 264 | 1 | 1 5045 | 3 | 5 | 1 | 264 | 1 | 1 8073 | 3 | 5 | 1 | 264 | 1 | 1 8163 | 3 | 5 | 1 | 264 | 1 | 1 9212 | 1 | 5 | 1 | 264 | 1 | 1 9873 | 1 | 5 | 1 | 264 | 1 | 1 (9 rows) ``` # STL\$1COMMIT\$1STATS Proporciona métricas relacionadas con el rendimiento de las confirmaciones, incluido el tiempo de distintas fases de confirmación y la cantidad de bloques confirmados. Consulte STL\$1COMMIT\$1STATS para determinar qué parte de una transacción se utilizó en la confirmación y cuántas colas hay en curso. STL\$1COMMIT\$1STATS 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_COMMIT_STATS.html) ## Consulta de ejemplo ``` select node, datediff(ms,startqueue,startwork) as queue_time, datediff(ms, startwork, endtime) as commit_time, queuelen from stl_commit_stats where xid = 2574 order by node; node | queue_time | commit_time | queuelen -----+--------------+-------------+--------- -1 | 0 | 617 | 0 0 | 444950725641 | 616 | 0 1 | 444950725636 | 616 | 0 ``` # STL\$1CONNECTION\$1LOG Registra los intentos de autenticación y las conexiones y desconexiones. STL\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_CONNECTION_LOG.html) ## Consultas de ejemplo Para ver los detalles de las conexiones abiertas, ejecute la siguiente consulta. ``` select recordtime, username, dbname, remotehost, remoteport from stl_connection_log where event = 'initiating session' and pid not in (select pid from stl_connection_log where event = 'disconnecting session') order by 1 desc; recordtime | username | dbname | remotehost | remoteport --------------------+-------------+------------+---------------+------------ 2014-11-06 20:30:06 | rdsdb | dev | [local] | 2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111 2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333 2014-11-05 20:28:35 | rdsdb | dev | [local] | (4 rows) ``` En el siguiente ejemplo, se refleja un intento fallido de autenticación y una correcta conexión y desconexión. ``` select event, recordtime, remotehost, username from stl_connection_log order by recordtime; event | recordtime | remotehost | username -----------------------+---------------------------+--------------+--------- authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john (4 rows) ``` 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 stl_connection_log; driver_version | os_version | plugin_name ----------------------------------------+-----------------------------------+-------------------- Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none ``` 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 stl_connection_log; os_version | driver_version | protocol_version --------------------------------+------------------------------+-------------------- Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 ``` # STL\$1DDLTEXT Captura las siguientes instrucciones DDL que se ejecutaron en el sistema. Estas instrucciones DDL incluyen las siguientes consultas y objetos: + CREATE SCHEMA, TABLE, VIEW + DROP SCHEMA, TABLE, VIEW + ALTER SCHEMA, TABLE Consulte también [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) y [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md). Estas vistas proporcionan una línea temporal de los comandos SQL que se ejecutan en el sistema; este historial es útil para solucionar problemas y para crear una traza de auditoría de todas las actividades del sistema. Utilice las columnas STARTTIME y ENDTIME para averiguar qué instrucciones se registraron durante un periodo determinado. Los bloques grandes de texto de SQL se dividen en líneas de 200 caracteres. La columna SEQUENCE identifica los segmentos de texto que pertenecen a una única instrucción. STL\$1DDLTEXT 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_DDLTEXT.html) ## Consultas de ejemplo La siguiente consulta devuelve registros que incluyen instrucciones DDL ejecutadas previamente. ``` select xid, starttime, sequence, substring(text,1,40) as text from stl_ddltext order by xid desc, sequence; ``` Aquí se incluye un resultado de ejemplo que muestra cuatro instrucciones CREATE TABLE. Las instrucciones DDL aparecen en la columna `text`, que se trunca para mejorar su legibilidad. ``` xid | starttime | sequence | text ------+----------------------------+----------+------------------------------------------ 1806 | 2013-10-23 00:11:14.709851 | 0 | CREATE TABLE supplier ( s_suppkey int4 N 1806 | 2013-10-23 00:11:14.709851 | 1 | s_comment varchar(101) NOT NULL ) 1805 | 2013-10-23 00:11:14.496153 | 0 | CREATE TABLE region ( r_regionkey int4 N 1804 | 2013-10-23 00:11:14.285986 | 0 | CREATE TABLE partsupp ( ps_partkey int8 1803 | 2013-10-23 00:11:14.056901 | 0 | CREATE TABLE part ( p_partkey int8 NOT N 1803 | 2013-10-23 00:11:14.056901 | 1 | ner char(10) NOT NULL , p_retailprice nu (6 rows) ``` ### Reconstruir SQL almacenados El siguiente SQL muestra las filas almacenadas en la columna `text` de STL\$1DDLTEXT. Las filas están ordenadas por `xid` y `sequence`. Si el SQL original tenía más de 200 caracteres en varias filas, STL\$1DDLTEXT puede contener varias filas por `sequence`. ``` SELECT xid, sequence, LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') WITHIN GROUP (ORDER BY sequence) as query_statement FROM stl_ddltext GROUP BY xid, sequence ORDER BY xid, sequence; ``` ``` xid | sequence | query_statement --------+-----------+----------------- 7886671 0 create external schema schema_spectrum_uddh\nfrom data catalog\ndatabase 'spectrum_db_uddh'\niam_role ''\ncreate external database if not exists; 7886752 0 CREATE EXTERNAL TABLE schema_spectrum_uddh.soccer_league\n(\n league_rank smallint,\n prev_rank smallint,\n club_name varchar(15),\n league_name varchar(20),\n league_off decimal(6,2),\n le 7886752 1 ague_def decimal(6,2),\n league_spi decimal(6,2),\n league_nspi smallint\n)\nROW FORMAT DELIMITED \n FIELDS TERMINATED BY ',' \n LINES TERMINATED BY '\\n\\l'\nstored as textfile\nLOCATION 's 7886752 2 3://mybucket-spectrum-uddh/'\ntable properties ('skip.header.line.count'='1'); ... ``` Para reconstruir el SQL almacenado en la columna `text` de STL\$1DDLTEXT, ejecute la siguiente instrucción SQL. Reúne las instrucciones DDL de uno o varios segmentos en la columna `text`. Antes de ejecutar el SQL reconstruido, sustituya cualquier carácter especial (`\n`) con una nueva línea en el cliente SQL. Los resultados de la siguiente instrucción SELECT reúnen tres filas secuenciales para reconstruir el SQL, en el campo `query_statement`. ``` SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement FROM stl_ddltext GROUP BY xid, endtime order by xid, endtime; ``` ``` query_statement -------------- create external schema schema_spectrum_uddh\nfrom data catalog\ndatabase 'spectrum_db_uddh'\niam_role ''\ncreate external database if not exists; CREATE EXTERNAL TABLE schema_spectrum_uddh.soccer_league\n(\n league_rank smallint,\n prev_rank smallint,\n club_name varchar(15),\n league_name varchar(20),\n league_off decimal(6,2),\n league_def decimal(6,2),\n league_spi decimal(6,2),\n league_nspi smallint\n)\nROW FORMAT DELIMITED \n FIELDS TERMINATED BY ',' \n LINES TERMINATED BY '\\n\\l'\nstored as textfile\nLOCATION 's3://mybucket-spectrum-uddh/'\ntable properties ('skip.header.line.count'='1'); ``` # STL\$1DELETE Analiza los pasos de ejecución de eliminación de las consultas. STL\$1DELETE 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** STL\$1DELETE solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_DELETE.html) ## Consultas de ejemplo Para crear una fila en STL\$1DELETE, en el siguiente ejemplo se inserta una fila en la tabla EVENT y, luego, se la elimina. Primero, se inserta una fila en la tabla EVENT y comprueba que se haya insertado. ``` insert into event(eventid,venueid,catid,dateid,eventname) values ((select max(eventid)+1 from event),95,9,1857,'Lollapalooza'); ``` ``` select * from event where eventname='Lollapalooza' order by eventid; ``` ``` eventid | venueid | catid | dateid | eventname | starttime ---------+---------+-------+--------+--------------+--------------------- 4274 | 102 | 9 | 1965 | Lollapalooza | 2008-05-01 19:00:00 4684 | 114 | 9 | 2105 | Lollapalooza | 2008-10-06 14:00:00 5673 | 128 | 9 | 1973 | Lollapalooza | 2008-05-01 15:00:00 5740 | 51 | 9 | 1933 | Lollapalooza | 2008-04-17 15:00:00 5856 | 119 | 9 | 1831 | Lollapalooza | 2008-01-05 14:00:00 6040 | 126 | 9 | 2145 | Lollapalooza | 2008-11-15 15:00:00 7972 | 92 | 9 | 2026 | Lollapalooza | 2008-07-19 19:30:00 8046 | 65 | 9 | 1840 | Lollapalooza | 2008-01-14 15:00:00 8518 | 48 | 9 | 1904 | Lollapalooza | 2008-03-19 15:00:00 8799 | 95 | 9 | 1857 | Lollapalooza | (10 rows) ``` Ahora, se elimina la fila que agregó en la tabla EVENT y se comprueba que se haya eliminado. ``` delete from event where eventname='Lollapalooza' and eventid=(select max(eventid) from event); ``` ``` select * from event where eventname='Lollapalooza' order by eventid; ``` ``` eventid | venueid | catid | dateid | eventname | starttime ---------+---------+-------+--------+--------------+--------------------- 4274 | 102 | 9 | 1965 | Lollapalooza | 2008-05-01 19:00:00 4684 | 114 | 9 | 2105 | Lollapalooza | 2008-10-06 14:00:00 5673 | 128 | 9 | 1973 | Lollapalooza | 2008-05-01 15:00:00 5740 | 51 | 9 | 1933 | Lollapalooza | 2008-04-17 15:00:00 5856 | 119 | 9 | 1831 | Lollapalooza | 2008-01-05 14:00:00 6040 | 126 | 9 | 2145 | Lollapalooza | 2008-11-15 15:00:00 7972 | 92 | 9 | 2026 | Lollapalooza | 2008-07-19 19:30:00 8046 | 65 | 9 | 1840 | Lollapalooza | 2008-01-14 15:00:00 8518 | 48 | 9 | 1904 | Lollapalooza | 2008-03-19 15:00:00 (9 rows) ``` Luego, se consulta la tabla stl\$1delete para ver lo pasos de ejecución de la eliminación. En este ejemplo, la consulta devolvió más de 300 filas, por lo que la siguiente salida está abreviada a título informativo. ``` select query, slice, segment, step, tasknum, rows, tbl from stl_delete order by query; ``` ``` query | slice | segment | step | tasknum | rows | tbl -------+-------+---------+------+---------+------+-------- 7 | 0 | 0 | 1 | 0 | 0 | 100000 7 | 1 | 0 | 1 | 0 | 0 | 100000 8 | 0 | 0 | 1 | 2 | 0 | 100001 8 | 1 | 0 | 1 | 2 | 0 | 100001 9 | 0 | 0 | 1 | 4 | 0 | 100002 9 | 1 | 0 | 1 | 4 | 0 | 100002 10 | 0 | 0 | 1 | 6 | 0 | 100003 10 | 1 | 0 | 1 | 6 | 0 | 100003 11 | 0 | 0 | 1 | 8 | 0 | 100253 11 | 1 | 0 | 1 | 8 | 0 | 100253 12 | 0 | 0 | 1 | 0 | 0 | 100255 12 | 1 | 0 | 1 | 0 | 0 | 100255 13 | 0 | 0 | 1 | 2 | 0 | 100257 13 | 1 | 0 | 1 | 2 | 0 | 100257 14 | 0 | 0 | 1 | 4 | 0 | 100259 14 | 1 | 0 | 1 | 4 | 0 | 100259 ... ``` # STL\$1DISK\$1FULL\$1DIAG Registra información sobre los errores producidos cuando el disco está lleno. STL\$1DISK\$1FULL\$1DIAG 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_STL_DISK_FULL_DIAG.html) ## Consultas de ejemplo El siguiente ejemplo devuelve información detallada acerca de los datos almacenados cuando hay un error de disco lleno. ``` select * from stl_disk_full_diag ``` El siguiente ejemplo convierte la cadena `currenttime` a una marca de hora. ``` select '2000-01-01'::timestamp + (currenttime/1000000.0)* interval '1 second' as currenttime,node_num,query_id,temp_blocks from pg_catalog.stl_disk_full_diag; ``` ``` currenttime | node_num | query_id | temp_blocks ----------------------------+----------+----------+------------- 2019-05-18 19:19:18.609338 | 0 | 569399 | 70982 2019-05-18 19:37:44.755548 | 0 | 569580 | 70982 2019-05-20 13:37:20.566916 | 0 | 597424 | 70869 ``` # STL\$1DIST Registra información acerca de la actividad de red durante la ejecución de los pasos de la consulta que distribuyen datos. Los números de filas, bytes y paquetes que se envían por la red durante un paso determinado en un sector determinado capturan el tráfico de red. La duración del paso es la diferencia entre la hora de inicio y de finalización del registro. Para identificar los pasos de distribución en una consulta, busque las etiquetas dist en la vista QUERY\$1SUMMARY o ejecute el comando EXPLAIN y luego busque atributos del paso que incluyan la etiqueta dist. STL\$1DIST 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** STL\$1DIST solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_DIST.html) ## Consultas de ejemplo El siguiente ejemplo devuelve información acerca de la distribución de las consultas con uno o más paquetes y con duración mayor que cero. ``` select query, slice, step, rows, bytes, packets, datediff(seconds, starttime, endtime) as duration from stl_dist where packets>0 and datediff(seconds, starttime, endtime)>0 order by query limit 10; ``` ``` query | slice | step | rows | bytes | packets | duration --------+-------+------+--------+---------+---------+----------- 567 | 1 | 4 | 49990 | 6249564 | 707 | 1 630 | 0 | 5 | 8798 | 408404 | 46 | 2 645 | 1 | 4 | 8798 | 408404 | 46 | 1 651 | 1 | 5 | 192497 | 9226320 | 1039 | 6 669 | 1 | 4 | 192497 | 9226320 | 1039 | 4 675 | 1 | 5 | 3766 | 194656 | 22 | 1 696 | 0 | 4 | 3766 | 194656 | 22 | 1 705 | 0 | 4 | 930 | 44400 | 5 | 1 111525 | 0 | 3 | 68 | 17408 | 2 | 1 (9 rows) ``` # STL\$1ERROR Registra los errores internos de procesamiento generados por el motor de base de datos de Amazon Redshift. STL\$1ERROR no registra los errores ni los mensajes de SQL. La información en STL\$1ERROR es útil para solucionar determinados errores. Un ingeniero de AWS Support podría pedirle que le proporcione esta información como parte del proceso de solución de problemas. STL\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. Para ver una lista de los códigos de error que se pueden generar al cargar datos con el comando Copy, consulte [Referencia de error de carga](r_Load_Error_Reference.md). ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_ERROR.html) ## Consultas de ejemplo En el siguiente ejemplo, se recupera información del error de STL\$1ERROR. ``` select process, errcode, linenum as line, trim(error) as err from stl_error; process | errcode | line | err --------------+---------+------+------------------------------------------------------------------ padbmaster | 8001 | 194 | Path prefix: s3://redshift-downloads/testnulls/venue.txt* padbmaster | 8001 | 529 | Listing bucket=redshift-downloads prefix=tests/category-csv-quotes padbmaster | 2 | 190 | database "template0" is not currently accepting connections padbmaster | 32 | 1956 | pq_flush: could not send data to client: Broken pipe (4 rows) ``` # STL\$1EXPLAIN Muestra el plan EXPLAIN de una consulta que se ha enviado para ejecutarse. STL\$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). **nota** STL\$1EXPLAIN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1EXPLAIN](SYS_QUERY_EXPLAIN.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_EXPLAIN.html) ## Consultas de ejemplo Analice la siguiente salida de EXPLAIN para una consulta de combinación de agregación: ``` explain select avg(datediff(day, listtime, saletime)) as avgwait from sales, listing where sales.listid = listing.listid; QUERY PLAN ------------------------------------------------------------------------------ XN Aggregate (cost=6350.30..6350.31 rows=1 width=16) -> XN Hash Join DS_DIST_NONE (cost=47.08..6340.89 rows=3766 width=16) Hash Cond: ("outer".listid = "inner".listid) -> XN Seq Scan on listing (cost=0.00..1924.97 rows=192497 width=12) -> XN Hash (cost=37.66..37.66 rows=3766 width=12) -> XN Seq Scan on sales (cost=0.00..37.66 rows=3766 width=12) (6 rows) ``` Si ejecuta esta consulta y su ID de consulta es 10, puede utilizar la tabla STL\$1EXPLAIN para ver el mismo tipo de información que devuelve el comando EXPLAIN: ``` select query,nodeid,parentid,substring(plannode from 1 for 30), substring(info from 1 for 20) from stl_explain where query=10 order by 1,2; query| nodeid |parentid| substring | substring -----+--------+--------+--------------------------------+------------------- 10 | 1 | 0 |XN Aggregate (cost=6717.61..6 | 10 | 2 | 1 | -> XN Merge Join DS_DIST_NO | Merge Cond:("outer" 10 | 3 | 2 | -> XN Seq Scan on lis | 10 | 4 | 2 | -> XN Seq Scan on sal | (4 rows) ``` Analice la siguiente consulta: ``` select event.eventid, sum(pricepaid) from event, sales where event.eventid=sales.eventid group by event.eventid order by 2 desc; eventid | sum --------+---------- 289 | 51846.00 7895 | 51049.00 1602 | 50301.00 851 | 49956.00 7315 | 49823.00 ... ``` Si el ID de esta consulta es 15, la siguiente consulta a la vista del sistema devolverá los nodos del plan que se completaron. En este caso, el orden de los nodos está invertido para mostrar el orden rea de la ejecución: ``` select query,nodeid,parentid,substring(plannode from 1 for 56) from stl_explain where query=15 order by 1, 2 desc; query|nodeid|parentid| substring -----+------+--------+-------------------------------------------------------- 15 | 8 | 7 | -> XN Seq Scan on eve 15 | 7 | 5 | -> XN Hash(cost=87.98..87.9 15 | 6 | 5 | -> XN Seq Scan on sales(cos 15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos 15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07.. 15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871 15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197. 15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87 (8 rows) ``` La siguiente consulta recupera los ID de consultas de todos los planes de consulta que tienen una función de ventana: ``` select query, trim(plannode) from stl_explain where plannode like '%Window%'; query| btrim -----+------------------------------------------------------------------------ 26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) 27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) (2 rows) ``` # STL\$1FILE\$1SCAN Devuelve los archivos que lee Amazon Redshift mientras carga los datos a través del comando COPY. Consultar esta vista puede ayudar a solucionar los errores de carga de datos. STL\$1FILE\$1SCAN puede ser muy útil para identificar problemas en las cargas de datos en paralelo porque, por lo general, las cargas de datos en paralelo cargan varios archivos con un mismo comando COPY. STL\$1FILE\$1SCAN 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** STL\$1FILE\$1SCAN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_FILE_SCAN.html) ## Consultas de ejemplo La siguiente consulta recupera los nombres y los tiempos de carga de todos los archivos que a Amazon Redshift le tomó más de 1 000 000 de microsegundos leer. ``` select trim(name)as name, loadtime from stl_file_scan where loadtime > 1000000; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` name | loadtime ---------------------------+---------- listings_pipe.txt | 9458354 allusers_pipe.txt | 2963761 allevents_pipe.txt | 1409135 tickit/listings_pipe.txt | 7071087 tickit/allevents_pipe.txt | 1237364 tickit/allusers_pipe.txt | 2535138 listings_pipe.txt | 6706370 allusers_pipe.txt | 3579461 allevents_pipe.txt | 1313195 tickit/allusers_pipe.txt | 3236060 tickit/listings_pipe.txt | 4980108 (11 rows) ``` # STL\$1HASH Analiza los pasos de ejecución hash de las consultas. STL\$1HASH 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** STL\$1HASH solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_HASH.html) ## Consultas de ejemplo El siguiente ejemplo devuelve información acerca de la cantidad de particiones que se utilizaron en una función hash para la consulta 720, y se indica que ningún paso se ejecutó en el disco. ``` select slice, rows, bytes, occupied, workmem, num_parts, est_rows, num_blocks_permitted, is_diskbased from stl_hash where query=720 and segment=5 order by slice; ``` ``` slice | rows | bytes | occupied | workmem | num_parts | est_rows | num_blocks_permitted | is_diskbased -------+------+--------+----------+----------+-----------+----------+----------------------+-------------- 0 | 145 | 585800 | 1 | 88866816 | 16 | 1 | 52 f 1 | 0 | 0 | 0 | 0 | 16 | 1 | 52 f (2 rows) ``` # STL\$1HASHJOIN Analiza los pasos de ejecución de combinación de las consultas. STL\$1HASHJOIN 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** STL\$1HASHJOIN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_HASHJOIN.html) ## Consultas de ejemplo El siguiente ejemplo devuelve la cantidad de particiones utilizadas en una combinación hash para la consulta 720. ``` select query, slice, tbl, num_parts from stl_hashjoin where query=720 limit 10; ``` ``` query | slice | tbl | num_parts -------+-------+-----+----------- 720 | 0 | 243 | 1 720 | 1 | 243 | 1 (2 rows) ``` # STL\$1INSERT Analiza los pasos de ejecución de inserción de las consultas. STL\$1INSERT 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** STL\$1INSERT solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_INSERT.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los pasos de ejecución de inserción para la consulta más reciente. ``` select slice, segment, step, tasknum, rows, tbl from stl_insert where query=pg_last_query_id(); ``` ``` slice | segment | step | tasknum | rows | tbl -------+---------+------+---------+-------+-------- 0 | 2 | 2 | 15 | 24958 | 100548 1 | 2 | 2 | 15 | 25032 | 100548 (2 rows) ``` # STL\$1LIMIT Analiza los pasos de ejecución que tienen lugar cuando se utiliza una cláusula LIMIT en una consulta SELECT. STL\$1LIMIT 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** STL\$1LIMIT solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_LIMIT.html) ## Consultas de ejemplo Para generar una fila en STL\$1LIMIT, este ejemplo primero ejecuta la siguiente consulta en la tabla VENUE con la cláusula LIMIT. ``` select * from venue order by 1 limit 10; ``` ``` venueid | venuename | venuecity | venuestate | venueseats ---------+----------------------------+-----------------+------------+------------ 1 | Toyota Park | Bridgeview | IL | 0 2 | Columbus Crew Stadium | Columbus | OH | 0 3 | RFK Stadium | Washington | DC | 0 4 | CommunityAmerica Ballpark | Kansas City | KS | 0 5 | Gillette Stadium | Foxborough | MA | 68756 6 | New York Giants Stadium | East Rutherford | NJ | 80242 7 | BMO Field | Toronto | ON | 0 8 | The Home Depot Center | Carson | CA | 0 9 | Dick's Sporting Goods Park | Commerce City | CO | 0 10 | Pizza Hut Park | Frisco | TX | 0 (10 rows) ``` Luego, ejecuta la siguiente consulta para encontrar el ID de consulta de la última consulta que se haya ejecutado en la tabla VENUE. ``` select max(query) from stl_query; ``` ``` max -------- 127128 (1 row) ``` Si lo desea, puede ejecutar la siguiente consulta para comprobar que el ID de consulta corresponde a la consulta LIMIT que ejecutó previamente. ``` select query, trim(querytxt) from stl_query where query=127128; ``` ``` query | btrim --------+------------------------------------------ 127128 | select * from venue order by 1 limit 10; (1 row) ``` Por último, ejecute la siguiente consulta para obtener información acerca de la consulta LIMIT de la tabla STL\$1LIMIT. ``` select slice, segment, step, starttime, endtime, tasknum from stl_limit where query=127128 order by starttime, endtime; ``` ``` slice | segment | step | starttime | endtime | tasknum -------+---------+------+----------------------------+----------------------------+--------- 1 | 1 | 3 | 2013-09-06 22:56:43.608114 | 2013-09-06 22:56:43.609383 | 15 0 | 1 | 3 | 2013-09-06 22:56:43.608708 | 2013-09-06 22:56:43.609521 | 15 10000 | 2 | 2 | 2013-09-06 22:56:43.612506 | 2013-09-06 22:56:43.612668 | 0 (3 rows) ``` # STL\$1LOAD\$1COMMITS 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. STL\$1LOAD\$1COMMITS 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** STL\$1LOAD\$1COMMITS solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_LOAD_COMMITS.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los detalles de la última operación COPY. ``` select query, trim(filename) as file, curtime as updated from stl_load_commits where query = pg_last_copy_id(); query | file | updated -------+----------------------------------+---------------------------- 28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486 (1 row) ``` La siguiente consulta tiene entradas para una carga nueva de las tablas en la base de datos TICKIT: ``` select query, trim(filename), curtime from stl_load_commits where filename like '%tickit%' order by query; ``` ``` query | btrim | curtime -------+---------------------------+---------------------------- 22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186 22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604 22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472 22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305 22485 | tickit/allevents_pipe.txt | 2013-02-08 20:58:29.99489 22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939 22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491 22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055 22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049 22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502 22603 | tickit/allevents_pipe.txt | 2013-02-08 21:04:14.785124 22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594 (12 rows) ``` 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 STL\$1LOAD\$1COMMITS y STL\$1QUERY a partir de una subconsulta de STL\$1UTILITYTEXT: ``` select l.query,rtrim(l.filename),q.xid from stl_load_commits l, stl_query q where l.query=q.query and exists (select xid from stl_utilitytext where xid=q.xid and rtrim("text")='COMMIT'); query | rtrim | xid -------+---------------------------+------- 22600 | tickit/date2008_pipe.txt | 68311 22480 | tickit/category_pipe.txt | 68066 7508 | allusers_pipe.txt | 23365 7552 | category_pipe.txt | 23415 7576 | allevents_pipe.txt | 23429 7516 | venue_pipe.txt | 23390 7604 | listings_pipe.txt | 23445 22596 | tickit/venue_pipe.txt | 68309 22605 | tickit/listings_pipe.txt | 68316 22593 | tickit/allusers_pipe.txt | 68305 22485 | tickit/allevents_pipe.txt | 68071 7561 | allevents_pipe.txt | 23429 7541 | category_pipe.txt | 23415 7558 | date2008_pipe.txt | 23428 22478 | tickit/venue_pipe.txt | 68065 526 | date2008_pipe.txt | 2572 7466 | allusers_pipe.txt | 23365 22482 | tickit/date2008_pipe.txt | 68067 22598 | tickit/category_pipe.txt | 68310 22603 | tickit/allevents_pipe.txt | 68315 22475 | tickit/allusers_pipe.txt | 68061 547 | date2008_pipe.txt | 2572 22487 | tickit/listings_pipe.txt | 68072 7531 | venue_pipe.txt | 23390 7583 | listings_pipe.txt | 23445 (25 rows) ``` En los ejemplos siguientes, se destacan los valores de columna is\$1partial y start\$1offset. ``` -- Single large file copy without scan range SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id(); 1 -- Single large uncompressed, delimited file copy with scan range SELECT count(*) FROM stl_load_commits WHERE query = pg_last_copy_id(); 16 -- Scan range offset logging in the file at 64MB boundary. SELECT start_offset FROM stl_load_commits WHERE query = pg_last_copy_id() ORDER BY start_offset; 0 67108864 134217728 201326592 268435456 335544320 402653184 469762048 536870912 603979776 671088640 738197504 805306368 872415232 939524096 1006632960 ``` # STL\$1LOAD\$1ERRORS Muestra los registros de todos los errores de carga de Amazon Redshift. STL\$1LOAD\$1ERRORS presenta un historial de todos los errores de carga de Amazon Redshift. Para obtener una lista completa de posibles errores y explicaciones de cargas, consulte [Referencia de error de carga](r_Load_Error_Reference.md). Consulte [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md) para obtener detalles adicionales, como la fila y la columna de datos exactas en las que se produjo un error de análisis, después de consultar STL\$1LOAD\$1ERRORS para encontrar información general sobre el error. STL\$1LOAD\$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). **nota** STL\$1LOAD\$1ERRORS solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_LOAD_ERRORS.html) ## Consultas de ejemplo La siguiente consulta combina STL\$1LOAD\$1ERRORS y STL\$1LOADERROR\$1DETAIL para ver los errores de detalles que se produjeron durante la carga más reciente. ``` select d.query, substring(d.filename,14,20), d.line_number as line, substring(d.value,1,16) as value, substring(le.err_reason,1,48) as err_reason from stl_loaderror_detail d, stl_load_errors le where d.query = le.query and d.query = pg_last_copy_id(); query | substring | line | value | err_reason -------+-------------------+------+----------+---------------------------- 558| allusers_pipe.txt | 251 | 251 | String contains invalid or unsupported UTF8 code 558| allusers_pipe.txt | 251 | ZRU29FGR | String contains invalid or unsupported UTF8 code 558| allusers_pipe.txt | 251 | Kaitlin | String contains invalid or unsupported UTF8 code 558| allusers_pipe.txt | 251 | Walter | String contains invalid or unsupported UTF8 code ``` En el siguiente ejemplo, se usa STL\$1LOAD\$1ERRORS con STV\$1TBL\$1PERM para crear una vista nueva y, luego, se usa esa vista para determinar qué errores se produjeron mientras se cargaban los datos en la tabla EVENT: ``` create view loadview as (select distinct tbl, trim(name) as table_name, query, starttime, trim(filename) as input, line_number, colname, err_code, trim(err_reason) as reason from stl_load_errors sl, stv_tbl_perm sp where sl.tbl = sp.id); ``` Luego, la consulta siguiente devuelve efectivamente el último error que se produjo mientras se cargaba la tabla EVENT: ``` select table_name, query, line_number, colname, starttime, trim(reason) as error from loadview where table_name ='event' order by line_number limit 1; ``` La consulta devuelve el último error de carga que se produjo para la tabla EVENT. Si no se produjeron errores de carga, la consulta devuelve cero filas. En este ejemplo, la consulta devuelve un error único: ``` table_name | query | line_number | colname | error | starttime ------+-----+----+----+--------------------------------------------------------+---------------------- event | 309 | 0 | 5 | Error in Timestamp value or format [%Y-%m-%d %H:%M:%S] | 2014-04-22 15:12:44 (1 row) ``` En los casos en que el comando COPY divide automáticamente datos de archivos grandes, sin comprimir y delimitados por texto para facilitar el paralelismo, las columnas *line\$1number*, *is\$1partial* y *start\$1offset* muestran información relativa a las divisiones. (El número de línea puede ser desconocido en los casos en que el número de línea del archivo original no esté disponible). ``` --scan ranges information SELECT line_number, POSITION, btrim(raw_line), btrim(raw_field_value), btrim(err_reason), is_partial, start_offset FROM stl_load_errors WHERE query = pg_last_copy_id(); --result -1,51,"1008771|13463413|463414|2|28.00|38520.72|0.06|0.07|NO|1998-08-30|1998-09-25|1998-09-04|TAKE BACK RETURN|RAIL|ans cajole sly","NO","Char length exceeds DDL length",1,67108864 ``` # STL\$1LOADERROR\$1DETAIL Muestra un registro de los errores de análisis de datos que ocurrieron mientras se usaba el comando COPY para cargar las tablas. Para conservar espacio en el disco, se registran 20 errores como máximo por sector de nodo para cada operación de carga. Un error de análisis ocurre cuando Amazon Redshift no puede analizar un campo en una fila de datos mientras lo carga en una tabla. Por ejemplo, si la columna de una tabla está esperando un tipo de datos entero y el archivo de datos tiene una cadena de letras en ese campo, se produce un error de análisis. Consulte STL\$1LOADERROR\$1DETAIL para obtener información adicional, como la fila y la columna de datos exactas en la que ocurrió un error de análisis, después de consultar [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) para averiguar información general sobre el error. La vista STL\$1LOADERROR\$1DETAIL tiene todas las columnas de datos, incluida la columna previa a aquella en la que ocurrió el error de análisis. Utilice el campo VALUE para ver el valor de los datos que realmente se analizaron en esta columna, incluidas las columnas que se analizaron correctamente hasta el error. 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). **nota** STL\$1LOADERROR\$1DETAIL solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_LOADERROR_DETAIL.html) ## Consulta de ejemplo La siguiente consulta combina STL\$1LOAD\$1ERRORS y STL\$1LOADERROR\$1DETAIL para ver los detalles de un error de análisis que ocurrió mientras se cargaba la tabla EVENT, que tiene un ID de tabla de 100133: ``` select d.query, d.line_number, d.value, le.raw_line, le.err_reason from stl_loaderror_detail d, stl_load_errors le where d.query = le.query and tbl = 100133; ``` En el siguiente ejemplo de salida, se muestran las columnas que se cargaron correctamente, incluida la columna con el error. En este ejemplo, se cargaron dos columnas correctamente antes de que ocurriera el error de análisis en la tercera columna, donde se analizó una cadena de caracteres incorrectamente para un campo que esperaba un valor entero. Como el campo esperaba un valor entero, analizó la cadena "aaa", que es un dato sin inicializar, como un valor nulo y generó un error de análisis. La salida muestra el valor sin procesar, el valor analizado y el motivo del error: ``` query | line_number | value | raw_line | err_reason -------+-------------+-------+----------+---------------- 4 | 3 | 1201 | 1201 | Invalid digit 4 | 3 | 126 | 126 | Invalid digit 4 | 3 | | aaa | Invalid digit (3 rows) ``` Cuando una consulta combina STL\$1LOAD\$1ERRORS y STL\$1LOADERROR\$1DETAIL, muestra un motivo de error por cada columna en la fila de datos, que simplemente significa que ocurrió un error en esa fila. La última fila en los resultados es la columna real en la que ocurrió el error. # STL\$1MERGE Analiza los pasos de ejecución de fusión de las consultas. Estos pasos tienen lugar cuando se combinan resultados de operaciones paralelas (como ordenaciones y combinaciones) para un posterior procesamiento. STL\$1MERGE 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** STL\$1MERGE solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_MERGE.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los resultados de 10 ejecuciones de fusión. ``` select query, step, starttime, endtime, tasknum, rows from stl_merge limit 10; ``` ``` query | step | starttime | endtime | tasknum | rows -------+------+---------------------+---------------------+---------+------ 9 | 0 | 2013-08-12 20:08:14 | 2013-08-12 20:08:14 | 0 | 0 12 | 0 | 2013-08-12 20:09:10 | 2013-08-12 20:09:10 | 0 | 0 15 | 0 | 2013-08-12 20:10:24 | 2013-08-12 20:10:24 | 0 | 0 20 | 0 | 2013-08-12 20:11:27 | 2013-08-12 20:11:27 | 0 | 0 26 | 0 | 2013-08-12 20:12:28 | 2013-08-12 20:12:28 | 0 | 0 32 | 0 | 2013-08-12 20:14:33 | 2013-08-12 20:14:33 | 0 | 0 38 | 0 | 2013-08-12 20:16:43 | 2013-08-12 20:16:43 | 0 | 0 44 | 0 | 2013-08-12 20:17:05 | 2013-08-12 20:17:05 | 0 | 0 50 | 0 | 2013-08-12 20:18:48 | 2013-08-12 20:18:48 | 0 | 0 56 | 0 | 2013-08-12 20:20:48 | 2013-08-12 20:20:48 | 0 | 0 (10 rows) ``` # STL\$1MERGEJOIN Analiza los pasos de ejecución de combinaciones de fusión de las consultas. STL\$1MERGEJOIN 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** STL\$1MERGEJOIN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_MERGEJOIN.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los resultados de combinaciones de fusión para la consulta más reciente. ``` select sum(s.qtysold), e.eventname from event e, listing l, sales s where e.eventid=l.eventid and l.listid= s.listid group by e.eventname; select * from stl_mergejoin where query=pg_last_query_id(); ``` ``` userid | query | slice | segment | step | starttime | endtime | tasknum | rows | tbl --------+-------+-------+---------+------+---------------------+---------------------+---------+------+----- 100 | 27399 | 3 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43428 | 240 100 | 27399 | 0 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43159 | 240 100 | 27399 | 2 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |42778 | 240 100 | 27399 | 1 | 4 | 4 | 2013-10-02 16:30:41 | 2013-10-02 16:30:41 | 19 |43091 | 240 ``` # STL\$1MV\$1STATE La vista STL\$1MV\$1STATE contiene una fila para cada transición de estado de una vista materializada. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). STL\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1MV\$1STATE](SYS_MV_STATE.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_MV_STATE.html) En la tabla siguiente se muestran ejemplos de combinaciones de `event_desc` y `state`. ``` event_desc | state -------------------------+--------------- TRUNCATE | Recompute TRUNCATE | Recompute Small table conversion | Recompute Vacuum | Recompute Column was renamed | Unrefreshable Column was dropped | Unrefreshable Table was renamed | Unrefreshable Column type was changed | Unrefreshable Schema name was changed | Unrefreshable ``` ## Consulta de ejemplo Para ver el registro de transiciones de estado de vistas materializadas, ejecute la siguiente consulta. ``` select * from stl_mv_state; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` userid | starttime | xid | event_desc | db_name | base_table_schema | base_table_name | mv_schema | mv_name | state --------+----------------------------+------+-----------------------------+---------+----------------------+----------------------+----------------------+---------------+--------------- 138 | 2020-02-14 02:21:25.578885 | 5180 | TRUNCATE | dev | public | mv_base_table | public | mv_test | Recompute 138 | 2020-02-14 02:21:56.846774 | 5275 | Column was dropped | dev | | mv_base_table | public | mv_test | Unrefreshable 100 | 2020-02-13 22:09:53.041228 | 1794 | Column was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable 1 | 2020-02-13 22:10:23.630914 | 1893 | ALTER TABLE ALTER SORTKEY | dev | public | mv_base_table_sorted | public | mv_test | Recompute 1 | 2020-02-17 22:57:22.497989 | 8455 | ALTER TABLE ALTER DISTSTYLE | dev | public | mv_base_table | public | mv_test | Recompute 173 | 2020-02-17 22:57:23.591434 | 8504 | Table was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable 173 | 2020-02-17 22:57:27.229423 | 8592 | Column type was changed | dev | | mv_base_table | public | mv_test | Unrefreshable 197 | 2020-02-17 22:59:06.212569 | 9668 | TRUNCATE | dev | schemaf796e415850f4f | mv_base_table | schemaf796e415850f4f | mv_test | Recompute 138 | 2020-02-14 02:21:55.705655 | 5226 | Column was renamed | dev | | mv_base_table | public | mv_test | Unrefreshable 1 | 2020-02-14 02:22:26.292434 | 5325 | ALTER TABLE ALTER SORTKEY | dev | public | mv_base_table_sorted | public | mv_test | Recompute ``` # STL\$1NESTLOOP Analiza los pasos de ejecución de combinaciones de bucle anidado de las consultas. STL\$1NESTLOOP 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** STL\$1NESTLOOP solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_NESTLOOP.html) ## Consultas de ejemplo Como la siguiente consulta no contempla la combinación con la tabla CATEGORY, produce un producto cartesiano parcial, que no es recomendable. Aquí se muestra para ilustrar un bucle anidado. ``` select count(event.eventname), event.eventname, category.catname, date.caldate from event, category, date where event.dateid = date.dateid group by event.eventname, category.catname, date.caldate; ``` La siguiente consulta muestra los resultados de la consulta anterior en la vista STL\$1NESTLOOP. ``` select query, slice, segment as seg, step, datediff(msec, starttime, endtime) as duration, tasknum, rows, tbl from stl_nestloop where query = pg_last_query_id(); ``` ``` query | slice | seg | step | duration | tasknum | rows | tbl -------+-------+-----+------+----------+---------+-------+----- 6028 | 0 | 4 | 5 | 41 | 22 | 24277 | 240 6028 | 1 | 4 | 5 | 26 | 23 | 24189 | 240 6028 | 3 | 4 | 5 | 25 | 23 | 24376 | 240 6028 | 2 | 4 | 5 | 54 | 22 | 23936 | 240 ``` # STL\$1PARSE Analiza los pasos de la consulta que analizan las cadenas en valores binarios para la carga. STL\$1PARSE 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** STL\$1PARSE solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_PARSE.html) ## Consultas de ejemplo El siguiente ejemplo devuelve todos los resultados de pasos de la consulta para el sector 1 y el segmento 0 donde se analizaron las cadenas en valores binarios. ``` select query, step, starttime, endtime, tasknum, rows from stl_parse where slice=1 and segment=0; ``` ``` query | step | starttime | endtime | tasknum | rows -------+------+---------------------+---------------------+---------+-------- 669 | 1 | 2013-08-12 22:35:13 | 2013-08-12 22:35:17 | 32 | 192497 696 | 1 | 2013-08-12 22:35:49 | 2013-08-12 22:35:49 | 32 | 0 525 | 1 | 2013-08-12 22:32:03 | 2013-08-12 22:32:03 | 13 | 49990 585 | 1 | 2013-08-12 22:33:18 | 2013-08-12 22:33:19 | 13 | 202 621 | 1 | 2013-08-12 22:34:03 | 2013-08-12 22:34:03 | 27 | 365 651 | 1 | 2013-08-12 22:34:47 | 2013-08-12 22:34:53 | 35 | 192497 590 | 1 | 2013-08-12 22:33:28 | 2013-08-12 22:33:28 | 19 | 0 599 | 1 | 2013-08-12 22:33:39 | 2013-08-12 22:33:39 | 31 | 11 675 | 1 | 2013-08-12 22:35:26 | 2013-08-12 22:35:27 | 38 | 3766 567 | 1 | 2013-08-12 22:32:47 | 2013-08-12 22:32:48 | 23 | 49990 630 | 1 | 2013-08-12 22:34:17 | 2013-08-12 22:34:17 | 36 | 0 572 | 1 | 2013-08-12 22:33:04 | 2013-08-12 22:33:04 | 29 | 0 645 | 1 | 2013-08-12 22:34:37 | 2013-08-12 22:34:38 | 29 | 8798 604 | 1 | 2013-08-12 22:33:47 | 2013-08-12 22:33:47 | 37 | 0 (14 rows) ``` # STL\$1PLAN\$1INFO Utilice la vista STL\$1PLAN\$1INFO para analizar la salida del comando EXPLAIN para una consulta en términos de conjunto de filas. Esta es una manera alternativa de analizar los planes de consulta. STL\$1PLAN\$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). **nota** STL\$1PLAN\$1INFO solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_PLAN_INFO.html) ## Consultas de ejemplo En los siguientes ejemplos, se comparan los planes de consulta para una consulta simple SELECT, que devuelve el uso del comando EXPLAIN y la consulta de la vista STL\$1PLAN\$1INFO. ``` explain select * from category; QUERY PLAN ------------------------------------------------------------- XN Seq Scan on category (cost=0.00..0.11 rows=11 width=49) (1 row) select * from category; catid | catgroup | catname | catdesc -------+----------+-----------+-------------------------------------------- 1 | Sports | MLB | Major League Baseball 3 | Sports | NFL | National Football League 5 | Sports | MLS | Major League Soccer ... select * from stl_plan_info where query=256; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+-------------+-----------+------+------- 256 | 1 | 0 | 1 | 0 | 104 | 0 | 0.11 | 11 | 539 256 | 1 | 0 | 0 | 0 | 104 | 0 | 0.11 | 11 | 539 (2 rows) ``` En este ejemplo, PLANNODE 104 hace referencia al examen secuencial de la tabla CATEGORY. ``` select distinct eventname from event order by 1; eventname ------------------------------------------------------------------------ .38 Special 3 Doors Down 70s Soul Jam A Bronx Tale ... explain select distinct eventname from event order by 1; QUERY PLAN ------------------------------------------------------------------------------------- XN Merge (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Merge Key: eventname -> XN Network (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Send to leader -> XN Sort (cost=1000000000136.38..1000000000137.82 rows=576 width=17) Sort Key: eventname -> XN Unique (cost=0.00..109.98 rows=576 width=17) -> XN Seq Scan on event (cost=0.00..87.98 rows=8798 width=17) (8 rows) select * from stl_plan_info where query=240 order by nodeid desc; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+------------------+------------------+------+-------- 240 | 5 | 0 | 0 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 5 | 0 | 1 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 4 | 0 | 2 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 0 | 3 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 0 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 1 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 3 | 1 | 2 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 3 | 2 | 0 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 2 | 2 | 1 | 0 | 123 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 1 | 3 | 0 | 0 | 122 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 (10 rows) ``` # STL\$1PROJECT Presenta las filas de los pasos de la consulta que se utilizaron para evaluar expresiones. STL\$1PROJECT 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** STL\$1PROJECT solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_PROJECT.html) ## Consultas de ejemplo El siguiente ejemplo devuelve todas las filas de los pasos de la consulta que se utilizaron para evaluar las expresiones del sector 0 y del segmento 1. ``` select query, step, starttime, endtime, tasknum, rows from stl_project where slice=0 and segment=1; ``` ``` query | step | starttime | endtime | tasknum | rows --------+------+---------------------+---------------------+---------+------ 86399 | 2 | 2013-08-29 22:01:21 | 2013-08-29 22:01:21 | 25 | -1 86399 | 3 | 2013-08-29 22:01:21 | 2013-08-29 22:01:21 | 25 | -1 719 | 1 | 2013-08-12 22:38:33 | 2013-08-12 22:38:33 | 7 | -1 86383 | 1 | 2013-08-29 21:58:35 | 2013-08-29 21:58:35 | 7 | -1 714 | 1 | 2013-08-12 22:38:17 | 2013-08-12 22:38:17 | 2 | -1 86375 | 1 | 2013-08-29 21:57:59 | 2013-08-29 21:57:59 | 2 | -1 86397 | 2 | 2013-08-29 22:01:20 | 2013-08-29 22:01:20 | 19 | -1 627 | 1 | 2013-08-12 22:34:13 | 2013-08-12 22:34:13 | 34 | -1 86326 | 2 | 2013-08-29 21:45:28 | 2013-08-29 21:45:28 | 34 | -1 86326 | 3 | 2013-08-29 21:45:28 | 2013-08-29 21:45:28 | 34 | -1 86325 | 2 | 2013-08-29 21:45:27 | 2013-08-29 21:45:27 | 28 | -1 86371 | 1 | 2013-08-29 21:57:42 | 2013-08-29 21:57:42 | 4 | -1 111100 | 2 | 2013-09-03 19:04:45 | 2013-09-03 19:04:45 | 12 | -1 704 | 2 | 2013-08-12 22:36:34 | 2013-08-12 22:36:34 | 37 | -1 649 | 2 | 2013-08-12 22:34:47 | 2013-08-12 22:34:47 | 38 | -1 649 | 3 | 2013-08-12 22:34:47 | 2013-08-12 22:34:47 | 38 | -1 632 | 2 | 2013-08-12 22:34:22 | 2013-08-12 22:34:22 | 13 | -1 705 | 2 | 2013-08-12 22:36:48 | 2013-08-12 22:36:49 | 13 | -1 705 | 3 | 2013-08-12 22:36:48 | 2013-08-12 22:36:49 | 13 | -1 3 | 1 | 2013-08-12 20:07:40 | 2013-08-12 20:07:40 | 3 | -1 86373 | 1 | 2013-08-29 21:57:58 | 2013-08-29 21:57:58 | 3 | -1 107976 | 1 | 2013-09-03 04:05:12 | 2013-09-03 04:05:12 | 3 | -1 86381 | 1 | 2013-08-29 21:58:35 | 2013-08-29 21:58:35 | 8 | -1 86396 | 1 | 2013-08-29 22:01:20 | 2013-08-29 22:01:20 | 15 | -1 711 | 1 | 2013-08-12 22:37:10 | 2013-08-12 22:37:10 | 20 | -1 86324 | 1 | 2013-08-29 21:45:27 | 2013-08-29 21:45:27 | 24 | -1 (26 rows) ``` # STL\$1QUERY Devuelve información acerca de la ejecución de la consulta de una base de datos. **nota** Las vistas STL\$1QUERY y STL\$1QUERYTEXT solo presentan información relacionada con consultas, no sobre otras utilidades y comandos de DDL. Para obtener una lista con información sobre todas las instrucciones ejecutadas por Amazon Redshift, también puede consultar las vistas STL\$1DDLTEXT y STL\$1UTILITYTEXT. Para obtener una lista completa de todas las instrucciones ejecutadas por Amazon Redshift, puede consultar la vista SVL\$1STATEMENTTEXT. STL\$1QUERY 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. Tenga en cuenta que cuando la longitud del texto de la consulta supera los 4000 caracteres, STL\$1QUERY solo muestra datos truncados. Para obtener el texto completo de la consulta, puede usar UNION en el texto de la consulta a través de las filas. **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 stlq.xid AS transaction_id, stlq.query AS query_id, TRIM(stlq.querytxt) AS query_text, th.status AS transaction_status FROM stl_query stlq LEFT JOIN sys_transaction_history th ON stlq.xid = th.transaction_id; ``` ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_QUERY.html) ## Consultas de ejemplo La siguiente consulta enumera las cinco consultas más recientes. ``` select query, trim(querytxt) as sqlquery from stl_query order by query desc limit 5; query | sqlquery ------+-------------------------------------------------- 129 | select query, trim(querytxt) from stl_query order by query; 128 | select node from stv_disk_read_speeds; 127 | select system_status from stv_gui_status 126 | select * from systable_topology order by slice 125 | load global dict registry (5 rows) ``` La siguiente consulta devuelve el tiempo transcurrido en orden descendente para las consultas ejecutadas el 15 de febrero de 2013. ``` select query, datediff(seconds, starttime, endtime), trim(querytxt) as sqlquery from stl_query where starttime >= '2013-02-15 00:00' and endtime < '2013-02-16 00:00' order by date_diff desc; query | date_diff | sqlquery -------+-----------+------------------------------------------- 55 | 119 | padb_fetch_sample: select count(*) from category 121 | 9 | select * from svl_query_summary; 181 | 6 | select * from svl_query_summary where query in(179,178); 172 | 5 | select * from svl_query_summary where query=148; ... (189 rows) ``` La siguiente consulta muestra el tiempo de cola y el tiempo de ejecución de las consultas. Las consultas con `concurrency_scaling_status = 1` se ejecutaron en un clúster de escalado de simultaneidad. Todas las demás consultas se ejecutaron en el clúster principal. ``` SELECT w.service_class AS queue , q.concurrency_scaling_status , COUNT( * ) AS queries , SUM( q.aborted ) AS aborted , SUM( ROUND( total_queue_time::NUMERIC / 1000000,2 ) ) AS queue_secs , SUM( ROUND( total_exec_time::NUMERIC / 1000000,2 ) ) AS exec_secs FROM stl_query q JOIN stl_wlm_query w USING (userid,query) WHERE q.userid > 1 AND service_class > 5 AND q.starttime > '2019-03-01 16:38:00' AND q.endtime < '2019-03-01 17:40:00' GROUP BY 1,2 ORDER BY 1,2; ``` # STL\$1QUERY\$1METRICS Presenta información acerca de las métricas, como la cantidad de filas procesadas, el uso de la CPU, la entrada/salida y el uso del disco para las consultas que se terminaron de ejecutar en colas de consultas (clases de servicios) definidas por el usuario. Para ver las métricas de las consultas activas que están actualmente en ejecución, consulte la vista de sistema [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md). Las métricas de consultas se muestran en intervalos de un segundo. Por este motivo, diferentes ejecuciones de la misma consulta pueden devolver horas que presentan una pequeña diferencia. Además, es posible que los segmentos de las consultas que se ejecutan en menos de un segundo no se registren. STL\$1QUERY\$1METRICS hace un seguimiento y agrega métricas en el nivel consulta, segmento y paso. Para obtener más información acerca de los segmentos y los pasos de las consultas, consulte [Flujo de trabajo de planificación y ejecución de consultas](c-query-planning.md). Distintas métricas (como `max_rows`, `cpu_time`, etc.) se suman en todos los sectores de un nodo. Para obtener más información acerca de los sectores de nodos, consulte [Arquitectura del sistema de almacenamiento de datos](c_high_level_system_architecture.md). Para determinar en qué nivel de fila se informa sobre las métricas, examine las columnas `segment` y `step_type`. + Si tanto `segment` como `step_type` son igual a `-1`, la fila se informa sobre las métricas en el nivel consulta. + Si `segment` no es `-1` y `step_type` es `-1`, la fila se informa sobre las métricas en el nivel segmento. + Si tanto `segment` como `step_type` no son `-1`, la fila se informa sobre las métricas en el nivel paso. La vista [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md) y la vista [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md) agrupan los datos en esta vista y presentan la información de una manera más accesible. STL\$1QUERY\$1METRICS 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_QUERY_METRICS.html) ## Consulta de ejemplo Para encontrar consultas con un tiempo alto de CPU (más de 1 000 segundos), ejecute la siguiente consulta. ``` Select query, cpu_time / 1000000 as cpu_seconds from stl_query_metrics where segment = -1 and cpu_time > 1000000000 order by cpu_time; query | cpu_seconds ------+------------ 25775 | 9540 ``` Para encontrar consultas activas con una combinación de bucle anidado que devolvieron más de un millón de filas, ejecute la siguiente consulta. ``` select query, rows from stl_query_metrics where step_type = 15 and rows > 1000000 order by rows; query | rows ------+----------- 25775 | 2621562702 ``` Para encontrar consultas activas que se ejecutaron por más de 60 segundos y que usaron menos de 10 segundos de tiempo de CPU, ejecute la siguiente consulta. ``` select query, run_time/1000000 as run_time_seconds from stl_query_metrics where segment = -1 and run_time > 60000000 and cpu_time < 10000000; query | run_time_seconds ------+----------------- 25775 | 114 ``` # STL\$1QUERYTEXT Captura el texto de la consulta para los comandos SQL. Consulte la vista STL\$1QUERYTEXT para capturar el SQL que se registró para las siguientes instrucciones: + SELECT, SELECT INTO + INSERT, UPDATE, DELETE + COPY + UNLOAD + Consultas generadas al ejecutar VACUUM y ANALYZE + CREATE TABLE AS (CTAS) Para consultar la actividad de estas instrucciones durante un periodo determinado, combine las vistas STL\$1QUERYTEXT y STL\$1QUERY. **nota** Las vistas STL\$1QUERY y STL\$1QUERYTEXT solo presentan información relacionada con consultas, no sobre otras utilidades y comandos de DDL. Para obtener una lista con información sobre todas las instrucciones ejecutadas por Amazon Redshift, también puede consultar las vistas STL\$1DDLTEXT y STL\$1UTILITYTEXT. Para obtener una lista completa de todas las instrucciones ejecutadas por Amazon Redshift, puede consultar la vista SVL\$1STATEMENTTEXT. Consulte también [STL\$1DDLTEXT](r_STL_DDLTEXT.md), [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) y [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md). STL\$1QUERYTEXT 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. Tenga en cuenta que cuando la longitud del texto de la consulta supera los 4000 caracteres, STL\$1QUERYTEXT solo muestra datos truncados. Para obtener el texto completo de la consulta, puede usar UNION en el texto de la consulta a través de las filas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_QUERYTEXT.html) ## Consultas de ejemplo Puede utilizar la función PG\$1BACKEND\$1PID() para recuperar información de la sesión actual. Por ejemplo, la siguiente consulta devuelve el ID de consulta y una parte de su texto para aquellas consultas que se hayan completado en la sesión actual. ``` select query, substring(text,1,60) from stl_querytext where pid = pg_backend_pid() order by query desc; query | substring -------+-------------------------------------------------------------- 28262 | select query, substring(text,1,80) from stl_querytext where 28252 | select query, substring(path,0,80) as path from stl_unload_l 28248 | copy category from 's3://dw-tickit/manifest/category/1030_ma 28247 | Count rows in target table 28245 | unload ('select * from category') to 's3://dw-tickit/manifes 28240 | select query, substring(text,1,40) from stl_querytext where (6 rows) ``` ### Reconstruyendo el SQL almacenado Para reconstruir el SQL almacenado en la columna `text` de STL\$1QUERYTEXT, ejecute una instrucción SELECT para crear SQL de 1 o más partes en la columna `text`. Antes de ejecutar el SQL reconstruido, reemplace cualquier caracter especial (`\n`) con una nueva línea. El resultado de la siguiente instrucción SELECT es filas de SQL reconstruido en el campo `query_statement`. ``` SELECT query, LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement, COUNT(*) as row_count FROM stl_querytext GROUP BY query ORDER BY query desc; ``` Por ejemplo, la siguiente búsqueda selecciona 3 columnas. La búsqueda en si misma es más larga de 200 caracteres y se guarda en varias partes en STL\$1QUERYTEXT. ``` select 1 AS a0123456789012345678901234567890123456789012345678901234567890, 2 AS b0123456789012345678901234567890123456789012345678901234567890, 3 AS b012345678901234567890123456789012345678901234 FROM stl_querytext; ``` En este ejemplo, la búsqueda se guarda en 2 partes (filas) en la columna `text` de STL\$1QUERYTEXT. ``` select query, sequence, text from stl_querytext where query=pg_last_query_id() order by query desc, sequence limit 10; ``` ``` query | sequence | text -------+----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 45 | 0 | select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234 45 | 1 | \nFROM stl_querytext; ``` Para reconstruir el SQL almacenado en STL\$1QUERYTEXT, ejecute el siguiente SQL. ``` select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS text from stl_querytext where query=pg_last_query_id(); ``` Para usar el SQL reconstruido resultante en su cliente, reemplace cualquier (`\n`) caracter especial con una nueva línea. ``` text ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234\nFROM stl_querytext; ``` # STL\$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 STL\$1REPLACEMENTS por cada una de las 100 primeras filas de cada sector del nodo que necesitaron al menos un reemplazo. STL\$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). **nota** STL\$1NESTLOOP solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_REPLACEMENTS.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los reemplazos de la operación COPY más reciente. ``` select query, session, filename, line_number, colname from stl_replacements where query = pg_last_copy_id(); query | session | filename | line_number | colname ------+---------+---------------------------------------------+-------------+-------- 96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 251 | city 96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 317 | city 96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 569 | city 96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 623 | city 96 | 6314 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 694 | city ... ``` # STL\$1RESTARTED\$1SESSIONS Para mantener una disponibilidad constante después de determinados eventos internos, Amazon Redshift podría reiniciar una sesión activa con un ID de proceso (PID) nuevo. Cuando Amazon Redshift reinicia una sesión, STL\$1RESTARTED\$1SESSIONS registra el PID nuevo y el PID anterior. Para obtener más información, vea los ejemplos a continuación en esta sección. STL\$1RESTARTED\$1SESSIONS 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_RESTARTED_SESSIONS.html) ## Consultas de ejemplo En el siguiente ejemplo, se combina STL\$1RESTARTED\$1SESSIONS con STL\$1SESSIONS para mostrar los nombres de usuario para las sesiones que se reiniciaron. ``` select process, stl_restarted_sessions.newpid, user_name from stl_sessions inner join stl_restarted_sessions on stl_sessions.process = stl_restarted_sessions.oldpid order by process; ... ``` # STL\$1RETURN Presenta detalles sobre los pasos de *devolución* de las consultas. Un paso de devolución devuelve los resultados de las consultas completadas en los nodos de informática al nodo principal. El nodo principal luego fusiona los datos y devuelve los resultados al cliente que los solicita. En el caso de las consultas completadas en el nodo principal, un paso de devolución devuelve los resultados al cliente. Una consulta consta de distintos segmentos y cada segmento consta de uno o más pasos. Para obtener más información, consulte [Procesamiento de consultas](c-query-processing.md). STL\$1RETURN 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** STL\$1RETURN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_RETURN.html) ## Consultas de ejemplo La siguiente consulta muestra qué pasos de la consulta más reciente se realizaron en cada sector. ``` SELECT query, slice, segment, step, endtime, rows, packets from stl_return where query = pg_last_query_id(); query | slice | segment | step | endtime | rows | packets -------+--------+---------+------+----------------------------+------+--------- 4 | 2 | 3 | 2 | 2013-12-27 01:43:21.469043 | 3 | 0 4 | 3 | 3 | 2 | 2013-12-27 01:43:21.473321 | 0 | 0 4 | 0 | 3 | 2 | 2013-12-27 01:43:21.469118 | 2 | 0 4 | 1 | 3 | 2 | 2013-12-27 01:43:21.474196 | 0 | 0 4 | 4 | 3 | 2 | 2013-12-27 01:43:21.47704 | 2 | 0 4 | 5 | 3 | 2 | 2013-12-27 01:43:21.478593 | 0 | 0 4 | 12811| 4 | 1 | 2013-12-27 01:43:21.480755 | 0 | 0 (7 rows) ``` # STL\$1S3CLIENT Registra el tiempo de transferencia y otras métricas de rendimiento. Utilice la tabla STL\$1S3CLIENT para encontrar el tiempo que duró la transferencia de datos desde Amazon S3. STL\$1S3CLIENT 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_STL_S3CLIENT.html) ## Consulta de ejemplo La siguiente consulta devuelve el tiempo que tardó la carga de archivos con el comando COPY. ``` select slice, key, transfer_time from stl_s3client where query = pg_last_copy_id(); ``` Resultado ``` slice | key | transfer_time ------+-----------------------------+--------------- 0 | listing10M0003_part_00 | 16626716 1 | listing10M0001_part_00 | 12894494 2 | listing10M0002_part_00 | 14320978 3 | listing10M0000_part_00 | 11293439 3371 | prefix=listing10M;marker= | 99395 ``` La siguiente búsqueda convierte el `start_time` y `end_time` en una marca de hora. ``` select userid,query,slice,pid,recordtime,start_time,end_time, '2000-01-01'::timestamp + (start_time/1000000.0)* interval '1 second' as start_ts, '2000-01-01'::timestamp + (end_time/1000000.0)* interval '1 second' as end_ts from stl_s3client where query> -1 limit 5; ``` ``` userid | query | slice | pid | recordtime | start_time | end_time | start_ts | end_ts --------+-------+-------+-------+----------------------------+-----------------+-----------------+----------------------------+---------------------------- 0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.207839 | 616436837154256 | 616436837207838 | 2019-07-14 16:27:17.154256 | 2019-07-14 16:27:17.207838 0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.252521 | 616436837208208 | 616436837252520 | 2019-07-14 16:27:17.208208 | 2019-07-14 16:27:17.25252 0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.284376 | 616436837208460 | 616436837284374 | 2019-07-14 16:27:17.20846 | 2019-07-14 16:27:17.284374 0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.285307 | 616436837208980 | 616436837285306 | 2019-07-14 16:27:17.20898 | 2019-07-14 16:27:17.285306 0 | 0 | 0 | 23449 | 2019-07-14 16:27:17.353853 | 616436837302216 | 616436837353851 | 2019-07-14 16:27:17.302216 | 2019-07-14 16:27:17.353851 ``` # STL\$1S3CLIENT\$1ERROR Registra los errores que surgieron en un sector mientras se cargaba un archivo desde Amazon S3. Utilice STL\$1S3CLIENT\$1ERROR para encontrar detalles acerca de los errores que surgieron mientras se transferían datos desde Amazon S3 como parte de un comando COPY. STL\$1S3CLIENT\$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/r_STL_S3CLIENT_ERROR.html) ## Notas de uso Si ve errores múltiples con "Connection timed out", es posible que tenga un problema de redes. Si está usando la función Enhanced VPC Routing, verifique que tiene una ruta de acceso a la red válida entre la VPC de su clúster y sus recursos de datos. Para obtener más información, consulte [Enrutamiento de VPC mejorada de Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/enhanced-vpc-routing.html). ## Consulta de ejemplo La siguiente consulta devuelve los errores de los comandos COPY completados durante la sesión actual. ``` select query, sliceid, substring(key from 1 for 20) as file, substring(error from 1 for 35) as error from stl_s3client_error where pid = pg_backend_pid() order by query desc; ``` Resultado ``` query | sliceid | file | error --------+---------+--------------------+------------------------------------ 362228 | 12 | part.tbl.25.159.gz | transfer closed with 1947655 bytes 362228 | 24 | part.tbl.15.577.gz | transfer closed with 1881910 bytes 362228 | 7 | part.tbl.22.600.gz | transfer closed with 700143 bytes r 362228 | 22 | part.tbl.3.34.gz | transfer closed with 2334528 bytes 362228 | 11 | part.tbl.30.274.gz | transfer closed with 699031 bytes r 362228 | 30 | part.tbl.5.509.gz | Unknown SSL protocol error in conne 361999 | 10 | part.tbl.23.305.gz | transfer closed with 698959 bytes r 361999 | 19 | part.tbl.26.582.gz | transfer closed with 1881458 bytes 361999 | 4 | part.tbl.15.629.gz | transfer closed with 2275907 bytes 361999 | 20 | part.tbl.6.456.gz | transfer closed with 692162 bytes r (10 rows) ``` # STL\$1SAVE Presenta detalles sobre los pasos para *guardar* de las consultas. Un paso guardar guarda la secuencia de entrada en una tabla transitoria. Una tabla transitoria es una tabla temporal que almacena resultados intermedios durante la ejecución de una consulta. Una consulta consta de distintos segmentos y cada segmento consta de uno o más pasos. Para obtener más información, consulte [Procesamiento de consultas](c-query-processing.md). STL\$1SAVE 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** STL\$1SAVE solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SAVE.html) ## Consultas de ejemplo La siguiente consulta muestra qué pasos de guardado de la consulta más reciente se realizaron en cada sector. ``` select query, slice, segment, step, tasknum, rows, tbl from stl_save where query = pg_last_query_id(); query | slice | segment | step | tasknum | rows | tbl -------+-------+---------+------+---------+------+----- 52236 | 3 | 0 | 2 | 21 | 0 | 239 52236 | 2 | 0 | 2 | 20 | 0 | 239 52236 | 2 | 2 | 2 | 20 | 0 | 239 52236 | 3 | 2 | 2 | 21 | 0 | 239 52236 | 1 | 0 | 2 | 21 | 0 | 239 52236 | 0 | 0 | 2 | 20 | 0 | 239 52236 | 0 | 2 | 2 | 20 | 0 | 239 52236 | 1 | 2 | 2 | 21 | 0 | 239 (8 rows) ``` # STL\$1SCAN Analiza los pasos de exámenes de tablas de las consultas. El número de paso para las filas de esta tabla siempre es 0 porque un examen es el primer paso de un segmento. STL\$1SCAN 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** STL\$1SCAN solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SCAN.html) ## Tipos de exámenes [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SCAN.html) ## Notas de uso Idealmente, `rows` debe tener un valor relativamente cercano a `rows_pre_filter`. Una gran diferencia entre `rows` y `rows_pre_filter` indica que el motor de ejecución está examinando filas que luego se descartan, lo cual es ineficaz. La diferencia entre `rows_pre_filter` y `rows_pre_user_filter` es la cantidad de filas fantasmas en el examen. Ejecute una función VACUUM para eliminar las filas marcadas para ser eliminadas. La diferencia entre `rows` y `rows_pre_user_filter` es la cantidad de filas filtradas por la consulta. Si se descartan muchas filas por el filtro del usuario, revise su elección de columna de ordenación o si el descarte se debe a una región desordenada de gran tamaño ejecute una limpieza. ## Consultas de ejemplo En el siguiente ejemplo, se muestra que `rows_pre_filter` es mayor que `rows_pre_user_filter` porque la tabla ha eliminado filas que no fueron limpiadas (filas fantasma). ``` SELECT query, slice, segment,step,rows, rows_pre_filter, rows_pre_user_filter from stl_scan where query = pg_last_query_id(); query | slice | segment | step | rows | rows_pre_filter | rows_pre_user_filter -------+--------+---------+------+-------+-----------------+---------------------- 42915 | 0 | 0 | 0 | 43159 | 86318 | 43159 42915 | 0 | 1 | 0 | 1 | 0 | 0 42915 | 1 | 0 | 0 | 43091 | 86182 | 43091 42915 | 1 | 1 | 0 | 1 | 0 | 0 42915 | 2 | 0 | 0 | 42778 | 85556 | 42778 42915 | 2 | 1 | 0 | 1 | 0 | 0 42915 | 3 | 0 | 0 | 43428 | 86856 | 43428 42915 | 3 | 1 | 0 | 1 | 0 | 0 42915 | 10000 | 2 | 0 | 4 | 0 | 0 (9 rows) ``` # STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS Registra la incidencia, marca de tiempo, XID y otros datos útiles cuando se excede una cuota de esquema. STL\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SCHEMA_QUOTA_VIOLATIONS.html) ## Consultas de ejemplo La siguiente consulta muestra el resultado de la infracción de cuota: ``` SELECT userid, TRIM(SCHEMA_NAME) "schema_name", quota, disk_usage, disk_usage_pct, timestamp FROM stl_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC; ``` Esta consulta devuelve el siguiente resultado de ejemplo para el esquema especificado: ``` userid | schema_name | quota | disk_usage | disk_usage_pct |timestamp -------+--------------+-------+------------+----------------+---------------------------- 104 | sales_schema | 2048 | 2798 | 136.62 | 2020-04-20 20:09:25.494723 (1 row) ``` # STL\$1SESSIONS Devuelve información acerca del historial de sesiones del usuario. STL\$1SESSIONS es diferente de STV\$1SESSIONS en cuanto a que STL\$1SESSIONS tiene el historial de sesiones, mientras que STV\$1SESSIONS tiene las sesiones activas actuales. STL\$1SESSIONS 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SESSIONS.html) ## Consultas de ejemplo Para ver el historial de sesiones para la base de datos TICKIT, escriba la siguiente consulta: ``` select starttime, process, user_name, timeout_sec, timed_out from stl_sessions where db_name='tickit' order by starttime; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` starttime | process | user_name | timeout_sec | timed_out ---------------------------+---------+------------------------+-------------+------------- 2008-09-15 09:54:06.746705 | 32358 | dwuser | 120 | 1 2008-09-15 09:56:34.30275 | 32744 | dwuser | 60 | 1 2008-09-15 11:20:34.694837 | 14906 | dwuser | 0 | 0 2008-09-15 11:22:16.749818 | 15148 | dwuser | 0 | 0 2008-09-15 14:32:44.66112 | 14031 | dwuser | 0 | 0 2008-09-15 14:56:30.22161 | 18380 | dwuser | 0 | 0 2008-09-15 15:28:32.509354 | 24344 | dwuser | 0 | 0 2008-09-15 16:01:00.557326 | 30153 | dwuser | 120 | 1 2008-09-15 17:28:21.419858 | 12805 | dwuser | 0 | 0 2008-09-15 20:58:37.601937 | 14951 | dwuser | 60 | 1 2008-09-16 11:12:30.960564 | 27437 | dwuser | 60 | 1 2008-09-16 14:11:37.639092 | 23790 | dwuser | 3600 | 1 2008-09-16 15:13:46.02195 | 1355 | dwuser | 120 | 1 2008-09-16 15:22:36.515106 | 2878 | dwuser | 120 | 1 2008-09-16 15:44:39.194579 | 6470 | dwuser | 120 | 1 2008-09-16 16:50:27.02138 | 17254 | dwuser | 120 | 1 2008-09-17 12:05:02.157208 | 8439 | dwuser | 3600 | 0 (17 rows) ``` # STL\$1SORT Muestra los pasos de ejecución de ordenación para las consultas; por ejemplo, los pasos que utiliza el procesamiento ORDER BY. STL\$1SORT 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** STL\$1SORT solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_SORT.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los resultados de ordenaciones para el sector 0 y el segmento 1. ``` select query, bytes, tbl, is_diskbased, workmem from stl_sort where slice=0 and segment=1; ``` ``` query | bytes | tbl | is_diskbased | workmem -------+---------+-----+--------------+----------- 567 | 3126968 | 241 | f | 383385600 604 | 5292 | 242 | f | 383385600 675 | 104776 | 251 | f | 383385600 525 | 3126968 | 251 | f | 383385600 585 | 5068 | 241 | f | 383385600 630 | 204808 | 266 | f | 383385600 704 | 0 | 242 | f | 0 669 | 4606416 | 241 | f | 383385600 696 | 104776 | 241 | f | 383385600 651 | 4606416 | 254 | f | 383385600 632 | 0 | 256 | f | 0 599 | 396 | 241 | f | 383385600 86397 | 0 | 242 | f | 0 621 | 5292 | 241 | f | 383385600 86325 | 0 | 242 | f | 0 572 | 5068 | 242 | f | 383385600 645 | 204808 | 241 | f | 383385600 590 | 396 | 242 | f | 383385600 (18 rows) ``` # STL\$1SSHCLIENT\$1ERROR Registra todos los errores vistos por el cliente Secure Shell (SSH, Shell seguro). STL\$1SSHCLIENT\$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/r_STL_SSHCLIENT_ERROR.html) # STL\$1STREAM\$1SEGS Muestra la relación entre las secuencias y los segmentos simultáneos. Los flujos en este contexto son flujos de Amazon Redshift. Esta vista del sistema no se refiere a [Ingesta de streaming a una vista materializada](materialized-view-streaming-ingestion.md). STL\$1STREAM\$1SEGS 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** STL\$1STREAM\$1SEGS solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_STREAM_SEGS.html) ## Consultas de ejemplo Para ver la relación entre las secuencias y los segmentos simultáneos de la consulta más reciente, escriba la siguiente consulta: ``` select * from stl_stream_segs where query = pg_last_query_id(); query | stream | segment -------+--------+--------- 10 | 1 | 2 10 | 0 | 0 10 | 2 | 4 10 | 1 | 3 10 | 0 | 1 (5 rows) ``` # STL\$1TR\$1CONFLICT Muestra información para identificar y resolver conflictos de transacciones con las tablas de las bases de datos. Los conflictos de transacciones se producen cuando dos o más usuarios están consultando y modificando filas de datos incluidas en tablas cuyas transacciones no se pueden serializar. La transacción que ejecuta una instrucción que rompería la capacidad de serialización se detiene y se revierte. Cada vez que se produce un conflicto en una transacción, Amazon Redshift escribe una fila de datos en la tabla de sistema STL\$1TR\$1CONFLICT con los detalles sobre la transacción cancelada. Para obtener más información, consulte [Niveles de aislamiento en Amazon Redshift](c_serial_isolation.md). STL\$1TR\$1CONFLICT 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_TR_CONFLICT.html) ## Consulta de ejemplo Para devolver información acerca de los conflictos relacionados con una tabla en particular, ejecute una consulta que especifique el ID de la tabla: ``` select * from stl_tr_conflict where table_id=100234 order by xact_start_ts; xact_id|process_| xact_start_ts | abort_time |table_ |id | | |id -------+--------+--------------------------+--------------------------+------ 1876 | 8551 |2010-03-30 09:19:15.852326|2010-03-30 09:20:17.582499|100234 1928 | 15034 |2010-03-30 13:20:00.636045|2010-03-30 13:20:47.766817|100234 1991 | 23753 |2010-04-01 13:05:01.220059|2010-04-01 13:06:06.94098 |100234 2002 | 23679 |2010-04-01 13:17:05.173473|2010-04-01 13:18:27.898655|100234 (4 rows) ``` Puede obtener el ID de la tabla de la sección DETAIL del mensaje de error para las violaciones de atributos serializables (error 1023). # STL\$1UNDONE Muestra información acerca de las transacciones que se deshicieron. STL\$1UNDONE 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_UNDONE.html) ## Consulta de ejemplo Para ver un registro preciso de todas las transacciones deshacer, escriba el siguiente comando: ``` select xact_id, xact_id_undone, table_id from stl_undone; ``` Este comando devuelve la siguiente salida de ejemplo: ``` xact_id | xact_id_undone | table_id ---------+----------------+---------- 1344 | 1344 | 100192 1326 | 1326 | 100192 1551 | 1551 | 100192 (3 rows) ``` # STL\$1UNIQUE Analiza los pasos de ejecución que tienen lugar cuando se utiliza una función DISTINCT en la lista SELECT o cuando se eliminan los duplicados en una consulta UNION o INTERSECT. STL\$1UNIQUE 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** STL\$1UNIQUE solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_UNIQUE.html) ## Consultas de ejemplo Suponga que ejecuta la siguiente consulta: ``` select distinct eventname from event order by 1; ``` Si suponemos que el ID de la consulta anterior es 6313, en el siguiente ejemplo se muestra la cantidad de filas que produjo el paso único para cada sector de los segmentos 0 y 1. ``` select query, slice, segment, step, datediff(msec, starttime, endtime) as msec, tasknum, rows from stl_unique where query = 6313 order by query desc, slice, segment, step; ``` ``` query | slice | segment | step | msec | tasknum | rows -------+-------+---------+------+------+---------+------ 6313 | 0 | 0 | 2 | 0 | 22 | 550 6313 | 0 | 1 | 1 | 256 | 20 | 145 6313 | 1 | 0 | 2 | 1 | 23 | 540 6313 | 1 | 1 | 1 | 42 | 21 | 127 6313 | 2 | 0 | 2 | 1 | 22 | 540 6313 | 2 | 1 | 1 | 255 | 20 | 158 6313 | 3 | 0 | 2 | 1 | 23 | 542 6313 | 3 | 1 | 1 | 38 | 21 | 146 (8 rows) ``` # STL\$1UNLOAD\$1LOG Registra los detalles de una operación de descarga. STL\$1UNLOAD\$1LOG registra una fila por cada archivo creado por una instrucción UNLOAD. Por ejemplo, si una instrucción UNLOAD crea 12 archivos, STL\$1UNLOAD\$1LOG tendrá 12 filas correspondientes. STL\$1UNLOAD\$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). **nota** STL\$1UNLOAD\$1LOG solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md) y [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_UNLOAD_LOG.html) ## Consulta de ejemplo Para obtener una lista de los archivos que se escribieron en Amazon S3 mediante un comando UNLOAD, puede llamar a una operación de lista de Amazon S3 una vez que se complete el comando UNLOAD. También puede consultar STL\$1UNLOAD\$1LOG. La siguiente consulta devuelve el nombre de la ruta de los archivos que se crearon a través de un comando UNLOAD para la última consulta completada: ``` select query, substring(path,0,40) as path from stl_unload_log where query = pg_last_query_id() order by path; ``` Este comando devuelve la siguiente salida de ejemplo: ``` query | path -------+-------------------------------------- 2320 | s3://amzn-s3-demo-bucket/venue0000_part_00 2320 | s3://amzn-s3-demo-bucket/venue0001_part_00 2320 | s3://amzn-s3-demo-bucket/venue0002_part_00 2320 | s3://amzn-s3-demo-bucket/venue0003_part_00 (4 rows) ``` # STL\$1USAGE\$1CONTROL La vista STL\$1USAGE\$1CONTROL contiene información que se registra cuando se alcanza un límite de uso. Para obtener más información acerca de los límites de uso, consulte [Administración de los límites de uso](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-usage-limits.html) en la *Guía de administración de Amazon Redshift*. Solo los superusuarios pueden ver STL\$1USAGE\$1CONTROL. 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_STL_USAGE_CONTROL.html) ## Consulta de ejemplo En el siguiente ejemplo de SQL, se devuelve parte de la información que se registra cuando se alcanza un límite de uso. ``` select query, pid, eventtime, feature_type from stl_usage_control order by eventtime desc limit 5; ``` # STL\$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) STL\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1USERLOG](SYS_USERLOG.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_USERLOG.html) ## Consultas de ejemplo En el siguiente ejemplo, se realizan cuatro acciones del usuario y, luego, se consulta la vista STL\$1USERLOG. ``` create user userlog1 password 'Userlog1'; alter user userlog1 createdb createuser; alter user userlog1 rename to userlog2; drop user userlog2; select userid, username, oldusername, action, usecreatedb, usesuper from stl_userlog order by recordtime desc; ``` ``` userid | username | oldusername | action | usecreatedb | usesuper --------+-----------+-------------+---------+-------------+---------- 108 | userlog2 | | drop | 1 | 1 108 | userlog2 | userlog1 | rename | 1 | 1 108 | userlog1 | | alter | 1 | 1 108 | userlog1 | | create | 0 | 0 (4 rows) ``` # STL\$1UTILITYTEXT Captura el texto de los comandos ejecutados en la base de datos que no son SELECT SQL. Consulte la vista STL\$1UTILITYTEXT para capturar el siguiente subconjunto de instrucciones SQL que se ejecutaron en el sistema: + ABORT, BEGIN, COMMIT, END, ROLLBACK + ANALYZE + CALL + CANCEL + COMMENT + CREATE, ALTER, DROP DATABASE + CREATE, ALTER, DROP USER + EXPLAIN + GRANT, REVOKE + LOCK + RESET + SET + SHOW + TRUNCATE Consulte también [STL\$1DDLTEXT](r_STL_DDLTEXT.md), [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) y [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md). Utilice las columnas STARTTIME y ENDTIME para averiguar qué instrucciones se registraron durante un periodo determinado. Los bloques grandes de texto de SQL se dividen en líneas de 200 caracteres. La columna SEQUENCE identifica los segmentos de texto que pertenecen a una única instrucción. La tabla del sistema STL\$1UTILITYTEXT admite las operaciones MANUAL REFRESH y AUTO REFRESH de las vistas materializadas. Para identificar AUTO REFRESH en las vistas materializadas, busque la columna `label`. Todas las consultas de AUTO REFRESH tienen una etiqueta con el valor `maintenance`. STL\$1UTILITYTEXT 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_UTILITYTEXT.html) ## Consultas de ejemplo La siguiente consulta devuelve el texto de los comandos "utility" que se ejecutaron el 26 de enero de 2012. En este caso, se ejecutaron algunos comandos SET y un comando SHOW ALL: ``` select starttime, sequence, rtrim(text) from stl_utilitytext where starttime like '2012-01-26%' order by starttime, sequence; starttime | sequence | rtrim ---------------------------+-----+---------------------------------- 2012-01-26 13:05:52.529235 | 0 | show all; 2012-01-26 13:20:31.660255 | 0 | SET query_group to '' 2012-01-26 13:20:54.956131 | 0 | SET query_group to 'soldunsold.sql' ... ``` ### Reconstruir SQL almacenados Para reconstruir el SQL almacenado en la columna `text` de STL\$1UTILITYTEXT, ejecute una instrucción SELECT para crear SQL de 1 o más partes en la columna `text`. Antes de ejecutar el SQL reconstruido, reemplace cualquier caracter especial (`\n`) con una nueva línea. El resultado de la siguiente instrucción SELECT es filas de SQL reconstruido en el campo `query_statement`. ``` SELECT LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END) WITHIN GROUP (ORDER BY sequence) as query_statement FROM stl_utilitytext GROUP BY xid order by xid; ``` Por ejemplo, la siguiente búsqueda establece el query\$1group a una cadena de ceros. La búsqueda en si misma es más larga de 200 caracteres y se guarda en varias partes en STL\$1UTILITYTEXT. ``` set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000'; ``` En este ejemplo, la búsqueda se guarda en 2 partes (filas) en la columna `text` de STL\$1UTILITYTEXT. ``` select query, sequence, text from stl_utilitytext where query=pg_last_query_id() order by query desc, sequence limit 10; ``` ``` starttime | sequence | text ----------------------------+----------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 2019-07-23 22:55:34.926198 | 0 | set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000 2019-07-23 22:55:34.926198 | 1 | 000000'; ``` Para reconstruir el SQL almacenado en STL\$1UTILITYTEXT, ejecute el siguiente SQL. ``` select LISTAGG(CASE WHEN LEN(RTRIM(text)) = 0 THEN text ELSE RTRIM(text) END, '') within group (order by sequence) AS query_statement from stl_utilitytext where query=pg_last_query_id(); ``` Para usar el SQL reconstruido resultante en su cliente, reemplace cualquier (`\n`) caracter especial con una nueva línea. ``` query_statement ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- set query_group to '00000000000000000000000000000000000000000000000000000000000000000000000000000000\n0000000000000000000000000000000000000000000000000000000000000000000000000000000000 000000'; ``` # STL\$1VACUUM Muestra las estadísticas de filas y de bloques de las tablas limpiadas. En la vista, se muestra información específica respecto a cuándo comenzó y finalizó la operación de limpieza y se especifican los beneficios de ejecutar la operación. Para obtener información acerca de los requisitos para ejecutar este comando, consulte la descripción del comando [VACUUM](r_VACUUM_command.md). STL\$1VACUUM 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_VACUUM.html) ## Consultas de ejemplo La siguiente consulta proporciona las estadísticas de limpieza de la tabla 108313. La tabla se limpió por medio de una serie de inserciones y eliminaciones. ``` select xid, table_id, status, rows, sortedrows, blocks, eventtime, reclaimable_rows, reclaimable_space_mb from stl_vacuum where table_id=108313 order by eventtime; xid | table_id | status | rows | sortedrows | blocks | eventtime | reclaimable_rows | reclaimable_space_mb -------+----------+-------------------------+------+------------+--------+----------------------+------------------+---------------------- 14294 | 108313 | Started | 1950 | 408 | 28 | 2016-05-19 17:36:01 | 984 | 17 14294 | 108313 | Finished | 966 | 966 | 11 | 2016-05-19 18:26:13 | 0 | 0 15126 | 108313 | Skipped(sorted>=95%) | 966 | 966 | 11 | 2016-05-19 18:26:38 | 0 | 0 ``` Al inicio de la operación VACUUM, la tabla contenía 1950 filas almacenadas en 28 bloques de 1 MB. Amazon Redshift estimó que podría recuperar 984 o 17 bloques de espacio en disco, con una operación de limpieza. En la fila del estado Finished (Finalizado), la columna ROWS muestra un valor de 966 y el valor de la columna BLOCKS es 11, en vez de 28. La operación de limpieza recuperó la cantidad estimada de espacio en disco y no quedó espacio ni filas recuperables una vez finalizada la operación de limpieza. En la fase de ordenación (transacción 15126), la limpieza pudo omitir la tabla porque las filas se insertaron en el orden de la clave de ordenación. En el siguiente ejemplo, se muestran las estadísticas de la limpieza SORT ONLY en la tabla SALES (tabla 110116 en este ejemplo) después de una gran operación INSERT: ``` vacuum sort only sales; select xid, table_id, status, rows, sortedrows, blocks, eventtime from stl_vacuum order by xid, table_id, eventtime; xid |table_id| status | rows |sortedrows|blocks| eventtime ----+--------+-----------------+-------+----------+------+-------------------- ... 2925| 110116 |Started Sort Only|1379648| 172456 | 132 | 2011-02-24 16:25:21... 2925| 110116 |Finished |1379648| 1379648 | 132 | 2011-02-24 16:26:28... ``` # STL\$1WINDOW Analiza los pasos de la consulta que realizan las funciones de ventana. STL\$1WINDOW 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** STL\$1WINDOW solo contiene consultas que se ejecutan en los clústeres aprovisionados principales. No contiene consultas que se ejecutan en clústeres de escalado simultáneo ni en espacios de nombres sin servidor. Para acceder a los planes de explicación de consultas ejecutadas tanto en los clústeres principales como en los clústeres de escalado simultáneo y en los espacios de nombres sin servidor, le recomendamos que utilice la vista de supervisión de SYS [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_WINDOW.html) ## Consultas de ejemplo El siguiente ejemplo devuelve los resultados de la función de ventana para el sector 0 y el segmento 3. ``` select query, tasknum, rows, is_diskbased, workmem from stl_window where slice=0 and segment=3; ``` ``` query | tasknum | rows | is_diskbased | workmem -------+---------+------+--------------+---------- 86326 | 36 | 1857 | f | 95256616 705 | 15 | 1857 | f | 95256616 86399 | 27 | 1857 | f | 95256616 649 | 10 | 0 | f | 95256616 (4 rows) ``` # STL\$1WLM\$1ERROR Registra todos los errores relacionados con la Workload Management (WLM, Administración de cargas de trabajo) a medida que se producen. STL\$1WLM\$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/r_STL_WLM_ERROR.html) # STL\$1WLM\$1RULE\$1ACTION Registra detalles de las acciones que surgen de las reglas de supervisión de consultas de la Workload Management (WLM, Administración de cargas de trabajo) asociadas a colas definidas por el usuario. Para obtener más información, consulte [Reglas de monitoreo de consultas de WLM](cm-c-wlm-query-monitoring-rules.md). STL\$1WLM\$1RULE\$1ACTION 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_STL_WLM_RULE_ACTION.html) ## Consultas de ejemplo En el siguiente ejemplo, se encuentran consultas que fueron detenidas por una regla de supervisión de consultas. ``` Select query, rule from stl_wlm_rule_action where action = 'abort' order by query; ``` # STL\$1WLM\$1QUERY Presenta un registro de cada intento de ejecución de una consulta en una clase de servicio gestionada por la Workload Management (WLM, Administración de cargas de trabajo). STL\$1WLM\$1QUERY 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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Los datos de la vista de monitoreo SYS están formateados para que sean más fáciles de usar y entender. Se recomienda utilizar la vista de monitoreo SYS para las consultas. ## Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STL_WLM_QUERY.html) ## Consultas de ejemplo **Obtención del tiempo promedio de las consultas de las colas y en ejecución** Las siguientes consultas muestran la configuración actual de las clases de servicio mayores que 4. Para obtener una lista de ID de clase de servicio, consulte [ID de la clase de servicio WLM](cm-c-wlm-system-tables-and-views.md#wlm-service-class-ids). La siguiente consulta devuelve el tiempo promedio (en microsegundos) que pasa cada consulta en las colas de consultas y el tiempo que están en ejecución para cada clase de servicio. ``` select service_class as svc_class, count(*), avg(datediff(microseconds, queue_start_time, queue_end_time)) as avg_queue_time, avg(datediff(microseconds, exec_start_time, exec_end_time )) as avg_exec_time from stl_wlm_query where service_class > 4 group by service_class order by service_class; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` svc_class | count | avg_queue_time | avg_exec_time -----------+-------+----------------+--------------- 5 | 20103 | 0 | 80415 5 | 3421 | 34015 | 234015 6 | 42 | 0 | 944266 7 | 196 | 6439 | 1364399 (4 rows) ``` **Obtención del tiempo máximo de las consultas de las colas y en ejecución** La siguiente consulta devuelve el tiempo máximo (en microsegundos) que pasa una consulta en alguna cola de consultas y el tiempo que está en ejecución para cada clase de servicio. ``` select service_class as svc_class, count(*), max(datediff(microseconds, queue_start_time, queue_end_time)) as max_queue_time, max(datediff(microseconds, exec_start_time, exec_end_time )) as max_exec_time from stl_wlm_query where svc_class > 5 group by service_class order by service_class; ``` ``` svc_class | count | max_queue_time | max_exec_time -----------+-------+----------------+--------------- 6 | 42 | 0 | 3775896 7 | 197 | 37947 | 16379473 (4 rows) ```