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/). # Referencia de las tablas y vistas de sistema Referencia de las tablas y vistas de sistema Amazon Redshift dispone de muchas tablas y vistas de sistema que contienen información acerca de cómo funciona el sistema. Puede consultar estas tablas y vistas de sistema de la misma forma que lo haría con cualquier otra tabla de bases de datos. En esta sección se muestran algunas consultas y explicaciones de ejemplo sobre las tablas de sistema: + Cómo se generan las diferentes vistas y tablas de sistema. + Qué tipos de información se puede obtener de estas tablas. + Cómo unir tablas de sistema de Amazon Redshift a tablas de catálogos + Cómo administrar el crecimiento de los archivos de registro de las tablas de sistema. Algunas tablas de sistema solo pueden ser utilizadas por el personal de AWS con fines de diagnóstico. En las siguientes secciones se explican las tablas de sistema que los administradores del sistema u otros usuarios de la base de datos pueden consultar para obtener información útil. **nota** Las tablas de sistema no están incluidas en los backups de clústeres manuales o automáticos (instantáneas). Las vistas del sistema STL retienen siete días del historial de registros. La retención de registros no requiere ninguna acción por parte del cliente, pero si desea almacenar datos de registro durante más de siete días, deberá copiarlos periódicamente en otras tablas o descargarlos en Amazon S3. **Topics** + [ ## Tipos de tablas y vistas de sistema ](#c_types-of-system-tables-and-views) + [ ## Visibilidad de datos en las tablas y vistas de sistema ](#c_visibility-of-data) + [ ## Migración de consultas aprovisionadas solo a consultas de vista de supervisión de SYS ](#sys_view_migration-use_cases) + [ ## Mejora del seguimiento de los identificadores de consultas mediante las vistas de monitoreo SYS ](#sys_view_migration-query-id) + [ ## Identificadores de consulta, proceso y sesión de tablas del sistema ](#system-table-query-process-session-ids) + [ # Vistas de metadatos SVV ](svv_views.md) + [ # Vistas de monitoreo de SYS ](serverless_views-monitoring.md) + [ # Asignación de la vista de sistema para migrar a las vistas de supervisión SYS ](sys_view_migration.md) + [ # Monitoreo del sistema (solo aprovisionado) ](c_intro_system_views.md) + [ # Tablas de catálogos de sistema ](c_intro_catalog_views.md) ## Tipos de tablas y vistas de sistema Tipos de tablas y vistas de sistema Existen varios tipos de tablas y vistas del sistema: + Las vistas SVV contienen información sobre los objetos de la base de datos con referencias a tablas STV transitorias. + Las vistas SYS se utilizan para monitorizar el uso de consultas y cargas de trabajo de los clústeres y grupos de trabajo sin servidor aprovisionados. + Las vistas STL se generan a partir de los registros que se han almacenado en el disco para proporcionar un historial del sistema. + Las tablas de STV son tablas de sistema virtuales que tienen instantáneas de los datos actuales del sistema. Están basadas en los datos transitorios en memoria y no se almacenan en los registros en disco o en las tablas normales. + Las vistas SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. + Las vistas SVL proporcionan detalles sobre las consultas en los clústeres principales. Las tablas y vistas de sistema no utilizan el mismo modelo de consistencia que las tablas normales. Es importante tener en cuenta este problema cuando se las consulta, en especial con las tablas STV y las vistas SVV. Por ejemplo, en el caso de una tabla t1 normal con una columna c1, se espera que la siguiente consulta no devuelva filas: ``` select * from t1 where c1 > (select max(c1) from t1) ``` No obstante, la siguiente consulta con una tabla de sistema puede devolver filas: ``` select * from stv_exec_state where currenttime > (select max(currenttime) from stv_exec_state) ``` La razón por la que esta consulta puede devolver filas es que currenttime es transitorio y las dos referencias de la consulta podrían no devolver el mismo valor cuando se evalúan. Por otra parte, la siguiente consulta puede no devolver filas: ``` select * from stv_exec_state where currenttime = (select max(currenttime) from stv_exec_state) ``` ## Visibilidad de datos en las tablas y vistas de sistema Visibilidad de datos en las tablas y vistas de sistema **nota** Amazon Redshift enmascara automáticamente determinadas columnas de las tablas del sistema al registrar información sobre las consultas realizadas en las vistas del catálogo de datos para evitar la exposición de metadatos confidenciales. Para obtener más información, consulte [Registro seguro](https://docs.aws.amazon.com/redshift/latest/mgmt/db-auditing-secure-logging.html) en la *Guía de administración de Amazon Redshift*. Existen dos clases de visibilidad para los datos de las tablas y vistas de sistema: visibilidad para los usuarios y visibilidad para los superusuarios. Los usuarios con privilegios de superusuario son los únicos que pueden ver los datos de las tablas visibles para los superusuarios. Los usuarios normales pueden ver los datos de las tablas visibles para los usuarios. Para brindar a un usuario normal acceso a tablas visibles para los superusuarios, concédale el privilegio SELECT de esa tabla. Para obtener más información, consulte [GRANT](r_GRANT.md). En las tablas visibles para los usuarios, de forma predeterminada, los usuarios normales no pueden ver las filas que generan otros usuarios. Si a un usuario normal se le concede [SYSLOG ACCESS UNRESTRICTED](r_ALTER_USER.md#alter-user-syslog-access), ese usuario podrá ver todas las filas de las tablas visibles para los usuarios, incluidas las que haya generado otro usuario. Para obtener más información, consulte [ALTER USER](r_ALTER_USER.md) o [CREATE USER](r_CREATE_USER.md). Todas las filas de SVV\$1TRANSACTIONS son visibles para todos los usuarios. Para obtener más información sobre la visibilidad de los datos, consulte el artículo de la base de conocimientos AWS re:Post [¿Cómo puedo conceder permiso a los usuarios normales de bases de datos de Amazon Redshift para ver los datos de las tablas del sistema de otros usuarios de mi clúster?](https://repost.aws/knowledge-center/amazon-redshift-system-tables). En el caso de las vistas de metadatos, Amazon Redshift no permite la visibilidad a los usuarios a los que se ha concedido SYSLOG ACCESS UNRESTRICTED. **nota** Al brindar a un usuario acceso sin restricciones a las tablas del sistema, le proporciona la visibilidad necesaria para ver los datos generados por otros usuarios. Por ejemplo, STL\$1QUERY y STL\$1QUERY\$1TEXT contienen todo el texto de las instrucciones INSERT, UPDATE y DELETE, que podrían contener datos confidenciales generados por los usuarios. Un super usuario puede ver todas las filas de todas las tablas. Para brindar a un usuario normal acceso a una tabla visible para los superusuarios, concédale el privilegio [GRANT](r_GRANT.md) SELECT de esta tabla. ### Filtrado de consultas generadas por el sistema Filtrado de consultas generadas por el sistema Las tablas y las vistas de sistema relacionadas con las consultas, como SVL\$1QUERY\$1SUMMARY, SVL\$1QLOG y otras, suelen contener una gran cantidad de instrucciones generadas automáticamente que Amazon Redshift utiliza para supervisar el estado de la base de datos. Estas consultas generadas por el sistema son visibles para un super usuario, pero raramente son útiles. Para filtrarlas cuando se selecciona de una tabla de sistema o vista de sistema que utiliza la columna `userid`, agregue la condición `userid > 1` a la cláusula WHERE. Por ejemplo: ``` select * from svl_query_summary where userid > 1 ``` ## Migración de consultas aprovisionadas solo a consultas de vista de supervisión de SYS ### Migración de clústeres aprovisionados a Amazon Redshift sin servidor Si va a migrar un clúster aprovisionado a Amazon Redshift sin servidor, es posible que tenga consultas que utilicen las siguientes vistas del sistema, que solo almacenan datos de clústeres aprovisionados. + Todas las vistas STL + Todas las vistas STV + Todas las vistas SVCS + Todas las vistas SVL + Algunas vistas SVV + Para obtener una lista completa de las vistas SVV no compatibles en Amazon Redshift sin servidor, consulte la lista que aparece al final de [Supervisión de consultas y cargas de trabajo con Amazon Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-monitoring.html) en la *Guía de administración de Amazon Redshift*. Para seguir utilizando sus consultas, reajústelas para utilizar las columnas definidas en las vistas de monitorización SYS que correspondan a las columnas de sus vistas aprovisionadas solo. Para ver la relación de asignación entre las vistas de solo aprovisionamiento y las vistas de supervisión de SYS, vaya a [Asignación de la vista de sistema para migrar a las vistas de supervisión SYS](sys_view_migration.md) ### Actualización de consultas mientras se permanece en un clúster aprovisionado Si no va a migrar a Amazon Redshift sin servidor, es posible que desee actualizar las consultas existentes. Las vistas de monitorización SYS están diseñadas para facilitar su utilización y reducir su complejidad, proporcionando una completa gama de métricas para monitorear y solucionar problemas de forma eficaz. Mediante vistas SYS como [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) y [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md) que consolidan la información de varias vistas aprovisionadas solo, puede agilizar sus consultas. ## Mejora del seguimiento de los identificadores de consultas mediante las vistas de monitoreo SYS Las vistas de monitoreo SYS, como [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md) y [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md), contienen la columna query\$1id, que incluye el identificador de las consultas de los usuarios. Del mismo modo, las vistas solo aprovisionadas, como [STL\$1QUERY](r_STL_QUERY.md) y [SVL\$1QLOG](r_SVL_QLOG.md), contienen la columna de consulta, que también incluye los identificadores de consultas. Sin embargo, los identificadores de consultas registrados en las vistas del sistema SYS son diferentes de los registrados en las vistas únicamente aprovisionadas. La diferencia entre los valores de la columna query\$1id de las vistas SYS y los valores de las columnas de consulta de las vistas únicamente aprovisionadas es la siguiente: + En las vistas SYS, la columna query\$1id registra las consultas enviadas por los usuarios en su formato original. El optimizador de Amazon Redshift puede dividirlas en consultas secundarias para mejorar el rendimiento, pero si ejecuta una sola consulta esta seguirá teniendo una sola fila en [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). Si desea ver las consultas secundarias individuales, puede consultarlas en [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). + En las vistas únicamente aprovisionadas, la columna de consultas registra las consultas en el nivel de consulta secundaria. Si el optimizador de Amazon Redshift reescribe la consulta original en varias consultas secundarias, habrá varias filas en [STL\$1QUERY](r_STL_QUERY.md) con valores de identificador de consulta diferentes para una sola consulta que ejecute. Cuando migre sus consultas de monitorep y diagnóstico de vistas únicamente aprovisionadas a vistas SYS, tenga en cuenta esta diferencia y edite las consultas en consecuencia. Para obtener más información sobre cómo procesa Amazon Redshift las consultas, consulte [Flujo de trabajo de planificación y ejecución de consultas](c-query-planning.md). ### Ejemplo Para ver un ejemplo de cómo Amazon Redshift registra las consultas de forma diferente en las vistas de supervisión de SYS y de solo aprovisionamiento, consulte la siguiente consulta de ejemplo. Esta es la consulta escrita tal y como la ejecutaría en Amazon Redshift. ``` SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1.l_suppkey AND o_orderkey = l1.l_orderkey AND o_orderstatus = 'F' AND l1.l_receiptdate > l1.l_commitdate AND EXISTS (SELECT * FROM lineitem l2 WHERE l2.l_orderkey = l1.l_orderkey AND l2.l_suppkey <> l1.l_suppkey ) AND NOT EXISTS (SELECT * FROM lineitem l3 WHERE l3.l_orderkey = l1.l_orderkey AND l3.l_suppkey <> l1.l_suppkey AND l3.l_receiptdate > l3.l_commitdate ) AND s_nationkey = n_nationkey AND n_name = 'UNITED STATES' GROUP BY s_name ORDER BY numwait DESC , s_name LIMIT 100; ``` Internamente, el optimizador de consultas de Amazon Redshift reescribe la consulta anterior enviada por el usuario en cinco consultas secundarias. La primera consulta secundaria crea una tabla temporal para materializar una subconsulta. ``` CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey , l_suppkey , s_name ) AS SELECT l1.l_orderkey , l1.l_suppkey , public.supplier.s_name FROM public.lineitem AS l1, public.nation, public.orders, public.supplier WHERE l1.l_commitdate < l1.l_receiptdate AND l1.l_orderkey = public.orders.o_orderkey AND l1.l_suppkey = public.supplier.s_suppkey AND public.nation.n_name = 'UNITED STATES'::CHAR(8) AND public.nation.n_nationkey = public.supplier.s_nationkey AND public.orders.o_orderstatus = 'F'::CHAR(1); ``` La segunda consulta secundaria recopila estadísticas de la tabla temporal. ``` padb_fetch_sample: select count(*) from volt_tt_606590308b512; ``` La tercera consulta secundaria crea otra tabla temporal para materializar otra subconsulta, que hace referencia a la tabla temporal creada anteriormente. ``` CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey , l_suppkey) AS (SELECT volt_tt_606590308b512.l_orderkey , volt_tt_606590308b512.l_suppkey FROM public.lineitem AS l2, volt_tt_606590308b512 WHERE l2.l_suppkey <> volt_tt_606590308b512.l_suppkey AND l2.l_orderkey = volt_tt_606590308b512.l_orderkey) EXCEPT distinct (SELECT volt_tt_606590308b512.l_orderkey, volt_tt_606590308b512.l_suppkey FROM public.lineitem AS l3, volt_tt_606590308b512 WHERE l3.l_commitdate < l3.l_receiptdate AND l3.l_suppkey <> volt_tt_606590308b512.l_suppkey AND l3.l_orderkey = volt_tt_606590308b512.l_orderkey); ``` La segunda consulta secundaria vuelve a recopilar las estadísticas de la tabla temporal. ``` padb_fetch_sample: select count(*) from volt_tt_606590308c2ef ``` La última consulta secundaria utiliza las tablas temporales creadas anteriormente para generar el resultado. ``` SELECT volt_tt_606590308b512.s_name AS s_name , COUNT(*) AS numwait FROM volt_tt_606590308b512, volt_tt_606590308c2ef WHERE volt_tt_606590308b512.l_orderkey = volt_tt_606590308c2ef.l_orderkey AND volt_tt_606590308b512.l_suppkey = volt_tt_606590308c2ef.l_suppkey GROUP BY 1 ORDER BY 2 DESC , 1 ASC LIMIT 100; ``` En la vista de sistema STL\$1QUERY, únicamente aprovisionada, Amazon Redshift registra cinco filas en el nivel de consulta secundaria, de la siguiente manera: ``` SELECT userid, xid, pid, query, querytxt::varchar(100); FROM stl_query WHERE xid = 48237350 ORDER BY xid, starttime; userid | xid | pid | query | querytxt --------+----------+------------+----------+------------------------------------------------------------------------------------------------------ 101 | 48237350 | 1073840810 | 12058151 | CREATE TEMP TABLE volt_tt_606590308b512(l_orderkey, l_suppkey, s_name) AS SELECT l1.l_orderkey, l1.l 101 | 48237350 | 1073840810 | 12058152 | padb_fetch_sample: select count(*) from volt_tt_606590308b512 101 | 48237350 | 1073840810 | 12058156 | CREATE TEMP TABLE volt_tt_606590308c2ef(l_orderkey, l_suppkey) AS (SELECT volt_tt_606590308b512.l_or 101 | 48237350 | 1073840810 | 12058168 | padb_fetch_sample: select count(*) from volt_tt_606590308c2ef 101 | 48237350 | 1073840810 | 12058170 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1. (5 rows) ``` En la vista de monitoreo SYS SYS\$1QUERY\$1HISTORY, Amazon Redshift registra la consulta de la siguiente manera: ``` SELECT user_id, transaction_id, session_id, query_id, query_text::varchar(100) FROM sys_query_history WHERE transaction_id = 48237350 ORDER BY start_time; user_id | transaction_id | session_id | query_id | query_text ---------+----------------+------------+----------+------------------------------------------------------------------------------------------------------ 101 | 48237350 | 1073840810 | 12058149 | SELECT s_name , COUNT(*) AS numwait FROM supplier, lineitem l1, orders, nation WHERE s_suppkey = l1. ``` En SYS\$1QUERY\$1DETAIL, puede buscar detalles a nivel de consulta secundaria utilizando el valor query\$1id de SYS\$1QUERY\$1HISTORY. La columna child\$1query\$1sequence muestra el orden en que se ejecutan las consultas secundarias. Para obtener más información sobre las columnas de SYS\$1QUERY\$1DETAIL, consulte [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). ``` select user_id, query_id, child_query_sequence, stream_id, segment_id, step_id, start_time, end_time, duration, blocks_read, blocks_write, local_read_io, remote_read_io, data_skewness, time_skewness, is_active, spilled_block_local_disk, spilled_block_remote_disk from sys_query_detail where query_id = 12058149 and step_id = -1 order by query_id, child_query_sequence, stream_id, segment_id, step_id; user_id | query_id | child_query_sequence | stream_id | segment_id | step_id | start_time | end_time | duration | blocks_read | blocks_write | local_read_io | remote_read_io | data_skewness | time_skewness | is_active | spilled_block_local_disk | spilled_block_remote_disk ---------+----------+----------------------+-----------+------------+---------+----------------------------+----------------------------+----------+-------------+--------------+---------------+----------------+---------------+---------------+-----------+--------------------------+--------------------------- 101 | 12058149 | 1 | 0 | 0 | -1 | 2023-09-27 15:40:38.512415 | 2023-09-27 15:40:38.533333 | 20918 | 0 | 0 | 0 | 0 | 0 | 44 | f | 0 | 0 101 | 12058149 | 1 | 1 | 1 | -1 | 2023-09-27 15:40:39.931437 | 2023-09-27 15:40:39.972826 | 41389 | 12 | 0 | 12 | 0 | 0 | 77 | f | 0 | 0 101 | 12058149 | 1 | 2 | 2 | -1 | 2023-09-27 15:40:40.584412 | 2023-09-27 15:40:40.613982 | 29570 | 32 | 0 | 32 | 0 | 0 | 25 | f | 0 | 0 101 | 12058149 | 1 | 2 | 3 | -1 | 2023-09-27 15:40:40.582038 | 2023-09-27 15:40:40.615758 | 33720 | 0 | 0 | 0 | 0 | 0 | 1 | f | 0 | 0 101 | 12058149 | 1 | 3 | 4 | -1 | 2023-09-27 15:40:46.668766 | 2023-09-27 15:40:46.705456 | 36690 | 24 | 0 | 15 | 0 | 0 | 17 | f | 0 | 0 101 | 12058149 | 1 | 4 | 5 | -1 | 2023-09-27 15:40:46.707209 | 2023-09-27 15:40:46.709176 | 1967 | 0 | 0 | 0 | 0 | 0 | 18 | f | 0 | 0 101 | 12058149 | 1 | 4 | 6 | -1 | 2023-09-27 15:40:46.70656 | 2023-09-27 15:40:46.71289 | 6330 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 1 | 5 | 7 | -1 | 2023-09-27 15:40:46.71405 | 2023-09-27 15:40:46.714343 | 293 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 2 | 0 | 0 | -1 | 2023-09-27 15:40:52.083907 | 2023-09-27 15:40:52.087854 | 3947 | 0 | 0 | 0 | 0 | 0 | 35 | f | 0 | 0 101 | 12058149 | 2 | 1 | 1 | -1 | 2023-09-27 15:40:52.089632 | 2023-09-27 15:40:52.091129 | 1497 | 0 | 0 | 0 | 0 | 0 | 11 | f | 0 | 0 101 | 12058149 | 2 | 1 | 2 | -1 | 2023-09-27 15:40:52.089008 | 2023-09-27 15:40:52.091306 | 2298 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 3 | 0 | 0 | -1 | 2023-09-27 15:40:56.882013 | 2023-09-27 15:40:56.897282 | 15269 | 0 | 0 | 0 | 0 | 0 | 29 | f | 0 | 0 101 | 12058149 | 3 | 1 | 1 | -1 | 2023-09-27 15:40:59.718554 | 2023-09-27 15:40:59.722789 | 4235 | 0 | 0 | 0 | 0 | 0 | 13 | f | 0 | 0 101 | 12058149 | 3 | 2 | 2 | -1 | 2023-09-27 15:40:59.800382 | 2023-09-27 15:40:59.807388 | 7006 | 0 | 0 | 0 | 0 | 0 | 58 | f | 0 | 0 101 | 12058149 | 3 | 3 | 3 | -1 | 2023-09-27 15:41:06.488685 | 2023-09-27 15:41:06.493825 | 5140 | 0 | 0 | 0 | 0 | 0 | 56 | f | 0 | 0 101 | 12058149 | 3 | 3 | 4 | -1 | 2023-09-27 15:41:06.486206 | 2023-09-27 15:41:06.497756 | 11550 | 0 | 0 | 0 | 0 | 0 | 2 | f | 0 | 0 101 | 12058149 | 3 | 4 | 5 | -1 | 2023-09-27 15:41:06.499201 | 2023-09-27 15:41:06.500851 | 1650 | 0 | 0 | 0 | 0 | 0 | 15 | f | 0 | 0 101 | 12058149 | 3 | 4 | 6 | -1 | 2023-09-27 15:41:06.498609 | 2023-09-27 15:41:06.500949 | 2340 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 3 | 5 | 7 | -1 | 2023-09-27 15:41:06.502945 | 2023-09-27 15:41:06.503282 | 337 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 4 | 0 | 0 | -1 | 2023-09-27 15:41:06.62899 | 2023-09-27 15:41:06.631452 | 2462 | 0 | 0 | 0 | 0 | 0 | 22 | f | 0 | 0 101 | 12058149 | 4 | 1 | 1 | -1 | 2023-09-27 15:41:06.632313 | 2023-09-27 15:41:06.63391 | 1597 | 0 | 0 | 0 | 0 | 0 | 20 | f | 0 | 0 101 | 12058149 | 4 | 1 | 2 | -1 | 2023-09-27 15:41:06.631726 | 2023-09-27 15:41:06.633813 | 2087 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 101 | 12058149 | 5 | 0 | 0 | -1 | 2023-09-27 15:41:12.571974 | 2023-09-27 15:41:12.584234 | 12260 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0 101 | 12058149 | 5 | 0 | 1 | -1 | 2023-09-27 15:41:12.569815 | 2023-09-27 15:41:12.585391 | 15576 | 0 | 0 | 0 | 0 | 0 | 4 | f | 0 | 0 101 | 12058149 | 5 | 1 | 2 | -1 | 2023-09-27 15:41:13.758513 | 2023-09-27 15:41:13.76401 | 5497 | 0 | 0 | 0 | 0 | 0 | 39 | f | 0 | 0 101 | 12058149 | 5 | 1 | 3 | -1 | 2023-09-27 15:41:13.749 | 2023-09-27 15:41:13.772987 | 23987 | 0 | 0 | 0 | 0 | 0 | 32 | f | 0 | 0 101 | 12058149 | 5 | 2 | 4 | -1 | 2023-09-27 15:41:13.799526 | 2023-09-27 15:41:13.813506 | 13980 | 0 | 0 | 0 | 0 | 0 | 62 | f | 0 | 0 101 | 12058149 | 5 | 2 | 5 | -1 | 2023-09-27 15:41:13.798823 | 2023-09-27 15:41:13.813651 | 14828 | 0 | 0 | 0 | 0 | 0 | 0 | f | 0 | 0 (28 rows) ``` ## Identificadores de consulta, proceso y sesión de tablas del sistema Al analizar los identificadores de consulta, proceso y sesión que aparecen en las tablas del sistema, tenga en cuenta lo siguiente: + El valor del identificador de consulta (en columnas como `query_id` y `query`) se puede reutilizar con el tiempo. + El valor del identificador de proceso o sesión (en columnas como `process_id`, `pid` y `session_id`) se puede reutilizar con el tiempo. + El valor del identificador de la transacción (en columnas como `transaction_id` y `xid`) es único. # Vistas de metadatos SVV Vistas de metadatos SVV Las vistas de SVV son vistas del sistema en Amazon Redshift que contienen información sobre objetos de base de datos. Tenga en cuenta que, aunque almacenan información como los permisos de usuario o los nombres de las tablas, no están pensadas para unirse a relaciones creadas por los usuarios. **nota** Amazon Redshift informa de una ADVERTENCIA, no de un ERROR, si se produce un error en una respuesta de base de datos por cualquier motivo. Amazon Redshift no envía mensajes de ERROR cuando se consultan objetos en un recurso compartido de datos. **Topics** + [ # SVV\$1ACTIVE\$1CURSORS ](r_SVV_ACTIVE_CURSORS.md) + [ # SVV\$1ALL\$1COLUMNS ](r_SVV_ALL_COLUMNS.md) + [ # SVV\$1ALL\$1SCHEMAS ](r_SVV_ALL_SCHEMAS.md) + [ # SVV\$1ALL\$1TABLES ](r_SVV_ALL_TABLES.md) + [ # SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS ](r_SVV_ALTER_TABLE_RECOMMENDATIONS.md) + [ # SVV\$1ATTACHED\$1MASKING\$1POLICY ](r_SVV_ATTACHED_MASKING_POLICY.md) + [ # SVV\$1COLUMNS ](r_SVV_COLUMNS.md) + [ # SVV\$1COLUMN\$1PRIVILEGES ](r_SVV_COLUMN_PRIVILEGES.md) + [ # SVV\$1COPY\$1JOB\$1INTEGRATIONS ](SVV_COPY_JOB_INTEGRATIONS.md) + [ # SVV\$1DATABASE\$1PRIVILEGES ](r_SVV_DATABASE_PRIVILEGES.md) + [ # SVV\$1DATASHARE\$1PRIVILEGES ](r_SVV_DATASHARE_PRIVILEGES.md) + [ # SVV\$1DATASHARES ](r_SVV_DATASHARES.md) + [ # SVV\$1DATASHARE\$1CONSUMERS ](r_SVV_DATASHARE_CONSUMERS.md) + [ # SVV\$1DATASHARE\$1OBJECTS ](r_SVV_DATASHARE_OBJECTS.md) + [ # SVV\$1DEFAULT\$1PRIVILEGES ](r_SVV_DEFAULT_PRIVILEGES.md) + [ # SVV\$1DISKUSAGE ](r_SVV_DISKUSAGE.md) + [ # SVV\$1EXTERNAL\$1COLUMNS ](r_SVV_EXTERNAL_COLUMNS.md) + [ # SVV\$1EXTERNAL\$1DATABASES ](r_SVV_EXTERNAL_DATABASES.md) + [ # SVV\$1EXTERNAL\$1PARTITIONS ](r_SVV_EXTERNAL_PARTITIONS.md) + [ # SVV\$1EXTERNAL\$1SCHEMAS ](r_SVV_EXTERNAL_SCHEMAS.md) + [ # SVV\$1EXTERNAL\$1TABLES ](r_SVV_EXTERNAL_TABLES.md) + [ # SVV\$1FUNCTION\$1PRIVILEGES ](r_SVV_FUNCTION_PRIVILEGES.md) + [ # SVV\$1GEOGRAPHY\$1COLUMNS ](r_SVV_GEOGRAPHY_COLUMNS.md) + [ # SVV\$1GEOMETRY\$1COLUMNS ](r_SVV_GEOMETRY_COLUMNS.md) + [ # SVV\$1IAM\$1PRIVILEGES ](r_SVV_IAM_PRIVILEGES.md) + [ # SVV\$1IDENTITY\$1PROVIDERS ](r_SVV_IDENTITY_PROVIDERS.md) + [ # SVV\$1INTEGRATION ](r_SVV_INTEGRATION.md) + [ # SVV\$1INTEGRATION\$1TABLE\$1MAPPING ](r_SVV_INTEGRATION_TABLE_MAPPING.md) + [ # SVV\$1INTEGRATION\$1TABLE\$1STATE ](r_SVV_INTEGRATION_TABLE_STATE.md) + [ # SVV\$1INTERLEAVED\$1COLUMNS ](r_SVV_INTERLEAVED_COLUMNS.md) + [ # SVV\$1LANGUAGE\$1PRIVILEGES ](r_SVV_LANUGAGE_PRIVILEGES.md) + [ # SVV\$1MASKING\$1POLICY ](r_SVV_MASKING_POLICY.md) + [ # SVV\$1ML\$1MODEL\$1INFO ](r_SVV_ML_MODEL_INFO.md) + [ # SVV\$1ML\$1MODEL\$1PRIVILEGES ](r_SVV_ML_MODEL_PRIVILEGES.md) + [ # SVV\$1MV\$1DEPENDENCY ](r_SVV_MV_DEPENDENCY.md) + [ # SVV\$1MV\$1INFO ](r_SVV_MV_INFO.md) + [ # SVV\$1QUERY\$1INFLIGHT ](r_SVV_QUERY_INFLIGHT.md) + [ # SVV\$1QUERY\$1STATE ](r_SVV_QUERY_STATE.md) + [ # SVV\$1REDSHIFT\$1COLUMNS ](r_SVV_REDSHIFT_COLUMNS.md) + [ # SVV\$1REDSHIFT\$1DATABASES ](r_SVV_REDSHIFT_DATABASES.md) + [ # SVV\$1REDSHIFT\$1FUNCTIONS ](r_SVV_REDSHIFT_FUNCTIONS.md) + [ # SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA ](r_SVV_REDSHIFT_SCHEMA_QUOTA.md) + [ # SVV\$1REDSHIFT\$1SCHEMAS ](r_SVV_REDSHIFT_SCHEMAS.md) + [ # SVV\$1REDSHIFT\$1TABLES ](r_SVV_REDSHIFT_TABLES.md) + [ # SVV\$1RELATION\$1PRIVILEGES ](r_SVV_RELATION_PRIVILEGES.md) + [ # SVV\$1RLS\$1APPLIED\$1POLICY ](r_SVV_RLS_APPLIED_POLICY.md) + [ # SVV\$1RLS\$1ATTACHED\$1POLICY ](r_SVV_RLS_ATTACHED_POLICY.md) + [ # SVV\$1RLS\$1POLICY ](r_SVV_RLS_POLICY.md) + [ # SVV\$1RLS\$1RELATION ](r_SVV_RLS_RELATION.md) + [ # SVV\$1ROLE\$1GRANTS ](r_SVV_ROLE_GRANTS.md) + [ # SVV\$1ROLES ](r_SVV_ROLES.md) + [ # SVV\$1SCHEMA\$1PRIVILEGES ](r_SVV_SCHEMA_PRIVILEGES.md) + [ # SVV\$1SCHEMA\$1QUOTA\$1STATE ](r_SVV_SCHEMA_QUOTA_STATE.md) + [ # SVV\$1SYSTEM\$1PRIVILEGES ](r_SVV_SYSTEM_PRIVILEGES.md) + [ # SVV\$1TABLE\$1INFO ](r_SVV_TABLE_INFO.md) + [ # SVV\$1TABLES ](r_SVV_TABLES.md) + [ # SVV\$1TRANSACTIONS ](r_SVV_TRANSACTIONS.md) + [ # SVV\$1USER\$1GRANTS ](r_SVV_USER_GRANTS.md) + [ # SVV\$1USER\$1INFO ](r_SVV_USER_INFO.md) + [ # SVV\$1VACUUM\$1PROGRESS ](r_SVV_VACUUM_PROGRESS.md) + [ # SVV\$1VACUUM\$1SUMMARY ](r_SVV_VACUUM_SUMMARY.md) # SVV\$1ACTIVE\$1CURSORS SVV\$1ACTIVE\$1CURSORS SVV\$1ACTIVE\$1CURSORS muestra los detalles de los cursores que están abiertos actualmente. Para obtener más información, consulte [DECLARE](declare.md). SVV\$1ACTIVE\$1CURSORS 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). Un usuario solo puede ver los cursores que él mismo haya abierto. Un superusuario puede ver todos los cursores. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ACTIVE_CURSORS.html) # SVV\$1ALL\$1COLUMNS SVV\$1ALL\$1COLUMNS Utilice SVV\$1ALL\$1COLUMNS para ver una unión de columnas de tablas de Amazon Redshift como se muestra en SVV\$1REDSHIFT\$1COLUMNS y la lista consolidada de todas las columnas externas de todas las tablas externas. Para obtener información acerca de las columnas de Amazon Redshift, consulte [SVV\$1REDSHIFT\$1COLUMNS](r_SVV_REDSHIFT_COLUMNS.md). SVV\$1ALL\$1COLUMNS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ALL_COLUMNS.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1ALL\$1COLUMNS. ``` SELECT * FROM svv_all_columns WHERE database_name = 'tickit_db' AND TABLE_NAME = 'tickit_sales_redshift' ORDER BY COLUMN_NAME, SCHEMA_NAME LIMIT 5; database_name | schema_name | table_name | column_name | ordinal_position | column_default | is_nullable | data_type | character_maximum_length | numeric_precision | numeric_scale | remarks --------------+-------------+-----------------------+-------------+------------------+----------------+-------------+-----------+--------------------------+-------------------+---------------+--------- tickit_db | public | tickit_sales_redshift | buyerid | 4 | | NO | integer | | 32 | 0 | tickit_db | public | tickit_sales_redshift | commission | 9 | | YES | numeric | | 8 | 2 | tickit_db | public | tickit_sales_redshift | dateid | 7 | | NO | smallint | | 16 | 0 | tickit_db | public | tickit_sales_redshift | eventid | 5 | | NO | integer | | 32 | 0 | tickit_db | public | tickit_sales_redshift | listid | 2 | | NO | integer | | 32 | 0 | ``` # SVV\$1ALL\$1SCHEMAS SVV\$1ALL\$1SCHEMAS Utilice SVV\$1ALL\$1SCHEMAS para ver una unión de esquemas de Amazon Redshift como se muestra en SVV\$1REDSHIFT\$1SCHEMAS y la lista consolidada de todos los esquemas externos de todas las bases de datos. Para obtener más información acerca de esquemas de Amazon Redshift, consulte [SVV\$1REDSHIFT\$1SCHEMAS](r_SVV_REDSHIFT_SCHEMAS.md). SVV\$1ALL\$1SCHEMAS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ALL_SCHEMAS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1ALL\$1SCHEMAS. ``` SELECT * FROM svv_all_schemas WHERE database_name = 'tickit_db' ORDER BY database_name, SCHEMA_NAME; database_name | schema_name | schema_owner | schema_type | schema_acl | source_database | schema_option ---------------+--------------------+--------------+-------------+------------+-----------------+--------------- tickit_db | public | 1 | shared | | | ``` # SVV\$1ALL\$1TABLES SVV\$1ALL\$1TABLES Utilice SVV\$1ALL\$1TABLES para ver una unión de tablas de Amazon Redshift como se muestra en SVV\$1REDSHIFT\$1TABLES y la lista consolidada de todas las tablas externas de todos los esquemas externos. Para obtener información acerca de las tablas de Amazon Redshift, consulte [SVV\$1REDSHIFT\$1TABLES](r_SVV_REDSHIFT_TABLES.md). SVV\$1ALL\$1TABLES 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ALL_TABLES.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1ALL\$1TABLES. ``` SELECT * FROM svv_all_tables WHERE database_name = 'tickit_db' ORDER BY TABLE_NAME, SCHEMA_NAME LIMIT 5; database_name | schema_name | table_name | table_type | table_acl | remarks ---------------+-------------+--------------------------+------------+-----------+--------- tickit_db | public | tickit_category_redshift | TABLE | | tickit_db | public | tickit_date_redshift | TABLE | | tickit_db | public | tickit_event_redshift | TABLE | | tickit_db | public | tickit_listing_redshift | TABLE | | tickit_db | public | tickit_sales_redshift | TABLE | | ``` Si el valor de table\$1acl es nulo, no se han concedido explícitamente privilegios de acceso a la tabla correspondiente. # SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS Registra las recomendaciones actuales de Amazon Redshift Advisor para tablas. En esta vista se muestran las recomendaciones para todas las tablas, tanto si están definidas para la optimización automática como si no. Para ver si una tabla está definida para la optimización automática, consulte [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md). Las entradas aparecen únicamente para las tablas visibles en la base de datos de la sesión actual. Una vez aplicada una recomendación, sea por Amazon Redshift o por usted mismo, ya no aparecerá en la vista. Solo los superusuarios pueden ver SVV\$1ALTER\$1TABLE\$1RECOMMENDATIONS. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ALTER_TABLE_RECOMMENDATIONS.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, las filas del resultado muestran recomendaciones para la clave de distribución y la clave de ordenación. Las filas también muestran si las recomendaciones son aptas para que Amazon Redshift las aplique automáticamente. ``` select type, database, table_id, group_id, ddl, auto_eligible from svv_alter_table_recommendations; ``` ``` type | database | table_id | group_id | ddl | auto_eligible diststyle | db0 | 117884 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f diststyle | db0 | 117892 | 2 | ALTER TABLE "sch"."dp21235_tbl_1" ALTER DISTSTYLE KEY DISTKEY "c0" | f diststyle | db0 | 117885 | 1 | ALTER TABLE "sch"."catalog_returns" ALTER DISTSTYLE KEY DISTKEY "cr_sold_date_sk", ALTER COMPOUND SORTKEY ("cr_sold_date_sk","cr_returned_time_sk") | t sortkey | db0 | 117890 | -1 | ALTER TABLE "sch"."customer_addresses" ALTER COMPOUND SORTKEY ("ca_address_sk") | t ``` # SVV\$1ATTACHED\$1MASKING\$1POLICY SVV\$1ATTACHED\$1MASKING\$1POLICY Utilice SVV\$1ATTACHED\$1MASKING\$1POLICY para ver todas las relaciones y los roles o los usuarios con políticas adjuntas a la base de datos conectada actualmente. Solo los superusuarios y los usuarios con el rol [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) pueden ver SVV\$1ATTACHED\$1MASKING\$1POLICY. Los usuarios normales verán 0 filas. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ATTACHED_MASKING_POLICY.html) ## Funciones internas Funciones internas SVV\$1ATTACHED\$1MASKING\$1POLICY admite las siguientes funciones internas: ### mask\$1get\$1policy\$1for\$1role\$1on\$1column mask\$1get\$1policy\$1for\$1role\$1on\$1column Obtiene la política de máxima prioridad que se aplica a un determinado par de columna-rol. #### Sintaxis Sintaxis ``` mask_get_policy_for_role_on_column (relschema, relname, colname, rolename); ``` #### Parameters Parameters *relschema* Nombre del esquema en el que se encuentra la política. *relname* Nombre de la tabla en la que se encuentra la política. *colname* Nombre de la columna a la que está asociada la política. *rolename* Nombre del rol al que está asociada la política. ### mask\$1get\$1policy\$1for\$1user\$1on\$1column mask\$1get\$1policy\$1for\$1user\$1on\$1column Obtiene la política de mayor prioridad que se aplica a un determinado par de columna-usuario. #### Sintaxis Sintaxis ``` mask_get_policy_for_user_on_column (relschema, relname, colname, username); ``` #### Parameters Parameters *relschema* Nombre del esquema en el que se encuentra la política. *relname* Nombre de la tabla en la que se encuentra la política. *colname* Nombre de la columna a la que está asociada la política. *rolename* Nombre del usuario al que está asociada la política. # SVV\$1COLUMNS SVV\$1COLUMNS Utilice SVV\$1COLUMNS para consultar información del catálogo sobre las columnas de las vistas y tablas tanto locales como externas, incluidas las [vistas de enlace de tiempo de ejecución](r_CREATE_VIEW.md#r_CREATE_VIEW_late-binding-views). SVV\$1COLUMNS es visible para todos los usuarios de forma predeterminada. Para controlar el acceso a los metadatos de la base de datos, habilite la seguridad de los metadatos para el clúster aprovisionado o el grupo de trabajo sin servidor. La seguridad de los metadatos le permite separar los permisos de visualización de los metadatos de los objetos por usuarios y roles. Para obtener más información, consulte [Seguridad de los metadatos](t_metadata_security.md). La vista SVV\$1COLUMNS combina metadatos de la tabla de las vistas del sistema [Tablas de catálogos de sistema](c_intro_catalog_views.md) (tablas con un prefijo PG) y [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md). Las tablas del catálogo del sistema describen las tablas de base de datos de Amazon Redshift. SVV\$1EXTERNAL\$1COLUMNS describe las tablas externas que se utilizan con Amazon Redshift Spectrum. Cualquier usuario puede ver todas las filas de las tablas de catálogo del sistema. Los usuarios normales pueden ver las definiciones de las columnas de la vista SVV\$1EXTERNAL\$1COLUMNS únicamente para las tablas externas para las que se les ha concedido acceso. Aunque los usuarios normales pueden ver los metadatos de las tablas de catálogo del sistema, solo pueden seleccionar datos de las tablas definidas por el usuario si son propietarios de la tabla o se les ha concedido acceso. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_COLUMNS.html) # SVV\$1COLUMN\$1PRIVILEGES SVV\$1COLUMN\$1PRIVILEGES Utilice SVV\$1COLUMN\$1PRIVILEGES para ver los permisos de columna que tienen concedidos de forma explícita los usuarios, roles y grupos de la base de datos actual. SVV\$1COLUMN\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_COLUMN_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1COLUMN\$1PRIVILEGES. ``` SELECT namespace_name,relation_name,COLUMN_NAME,privilege_type,identity_name,identity_type FROM svv_column_privileges WHERE relation_name = 'lineitem'; namespace_name | relation_name | column_name | privilege_type | identity_name | identity_type ----------------+---------------+-------------+----------------+---------------+---------------- public | lineitem | l_orderkey | SELECT | reguser | user public | lineitem | l_orderkey | SELECT | role1 | role public | lineitem | l_partkey | SELECT | reguser | user public | lineitem | l_partkey | SELECT | role1 | role ``` # SVV\$1COPY\$1JOB\$1INTEGRATIONS SVV\$1COPY\$1JOB\$1INTEGRATIONS Utilice SVV\$1COPY\$1JOB\$1INTEGRATIONS para ver los detalles de las integraciones de eventos de S3. Esta vista contiene las integraciones de eventos de S3 que se han creado. SVV\$1COPY\$1JOB\$1INTEGRATIONS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SVV_COPY_JOB_INTEGRATIONS.html) El siguiente ejemplo devuelve las integraciones de S3 para la base de datos actual. ``` SELECT * FROM SVV_COPY_JOB_INTEGRATIONS WHERE db_name = pg_catalog.current_database(); ``` # SVV\$1DATABASE\$1PRIVILEGES SVV\$1DATABASE\$1PRIVILEGES Utilice SVV\$1DATABASE\$1PRIVILEGES para ver los permisos de base de datos que tienen concedidos de forma explícita los usuarios, roles y grupos del clúster de Amazon Redshift. SVV\$1DATABASE\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DATABASE_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1DATABASE\$1PRIVILEGES. ``` SELECT database_name,privilege_type,identity_name,identity_type,admin_option FROM svv_database_privileges WHERE database_name = 'test_db'; database_name | privilege_type | identity_name | identity_type | admin_option ---------------+----------------+---------------+---------------+-------------- test_db | CREATE | reguser | user | False test_db | CREATE | role1 | role | False test_db | TEMP | public | public | False test_db | TEMP | role1 | role | False ``` # SVV\$1DATASHARE\$1PRIVILEGES SVV\$1DATASHARE\$1PRIVILEGES Utilice SVV\$1DATASHARE\$1PRIVILEGES para ver los permisos de recurso compartido de datos que tienen concedidos de forma explícita los usuarios, roles y grupos del clúster de Amazon Redshift. SVV\$1DATASHARE\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DATASHARE_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1DATASHARE\$1PRIVILEGES. ``` SELECT datashare_name,privilege_type,identity_name,identity_type,admin_option FROM svv_datashare_privileges WHERE datashare_name = 'demo_share'; datashare_name | privilege_type | identity_name | identity_type | admin_option ----------------+----------------+----------------+---------------+-------------- demo_share | ALTER | superuser | user | False demo_share | ALTER | reguser | user | False ``` # SVV\$1DATASHARES SVV\$1DATASHARES Utilice SVV\$1DATASHARES para ver una lista de los recursos compartidos de datos creados en el clúster, así como de los que están compartidos con el clúster. SVV\$1DATASHARES es visible para los siguientes usuarios: + Superusuarios + Propietarios del recurso compartido de datos + Usuarios con permisos ALTER o USAGE en un recurso compartido de datos Otros usuarios no pueden ver ninguna fila. Para obtener más información sobre los permisos ALTER y USAGE, consulte [GRANT](r_GRANT.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DATASHARES.html) ## Notas de uso Notas de uso **Recuperación de metadatos adicionales**: con el número entero devuelto en la columna `share_owner`, puede unirlo con `usesysid` en [SVL\$1USER\$1INFO](r_SVL_USER_INFO.md) para obtener datos sobre el propietario del recurso compartido de datos. Esto incluye el nombre y las propiedades adicionales. ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve la salida para SVV\$1DATASHARES. ``` SELECT share_owner, source_database, share_type, is_publicaccessible FROM svv_datashares WHERE share_name LIKE 'tickit_datashare%' AND source_database = 'dev'; share_owner | source_database | share_type | is_publicaccessible --------------+-----------------+-------------+---------------------- 100 | dev | OUTBOUND | True (1 rows) ``` El siguiente ejemplo devuelve el resultado para SVV\$1DATASHARES para los recursos compartidos de datos de salida. ``` SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'OUTBOUND'; share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account| producer_namespace | managed_by ----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+-----------------+--------------------------------------+------------ salesshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | marketingshare | 1 | dev | | OUTBOUND | True | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | ``` El siguiente ejemplo devuelve el resultado para SVV\$1DATASHARES para los recursos compartidos de datos de entrada. ``` SELECT share_name, share_owner, btrim(source_database), btrim(consumer_database), share_type, is_publicaccessible, share_acl, btrim(producer_account), btrim(producer_namespace), btrim(managed_by) FROM svv_datashares WHERE share_type = 'INBOUND'; share_name | share_owner | source_database | consumer_database | share_type | is_publicaccessible | share_acl | producer_account | producer_namespace | managed_by ----------------+-------------+-----------------+-------------------+------------+---------------------+-----------+------------------+--------------------------------------+------------ salesshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | marketingshare | | | | INBOUND | False | | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | ADX ``` # SVV\$1DATASHARE\$1CONSUMERS SVV\$1DATASHARE\$1CONSUMERS Utilice SVV\$1DATASHARE\$1CONSUMERS para ver una lista de consumidores de un datashare creado en un clúster. SVV\$1DATASHARE\$1CONSUMERS es visible para los siguientes usuarios: + Superusuarios + Propietarios del recurso compartido de datos + Usuarios con permisos ALTER o USAGE en un recurso compartido de datos Otros usuarios no pueden ver ninguna fila. Para obtener más información sobre los permisos ALTER y USAGE, consulte [GRANT](r_GRANT.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DATASHARE_CONSUMERS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1DATASHARE\$1CONSUMERS. ``` SELECT count(*) FROM svv_datashare_consumers WHERE share_name LIKE 'tickit_datashare%'; 1 ``` # SVV\$1DATASHARE\$1OBJECTS SVV\$1DATASHARE\$1OBJECTS Utilice SVV\$1DATASHARE\$1OBJECTS para ver una lista de objetos de todos los datashares creados en el clúster o compartidos con el clúster. SVV\$1DATASHARE\$1OBJECTS 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). Para obtener información sobre cómo ver una lista de recursos compartidos de datos, consulte [SVV\$1DATASHARES.](https://docs.aws.amazon.com/redshift/latest/dg/r_SVV_DATASHARES.html) ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DATASHARE_OBJECTS.html) ## Consulta de ejemplo Consulta de ejemplo Los siguientes ejemplos devuelven el resultado de SVV\$1DATASHARE\$1OBJECTS. ``` SELECT share_type, btrim(share_name)::varchar(16) AS share_name, object_type, object_name FROM svv_datashare_objects WHERE share_name LIKE 'tickit_datashare%' AND object_name LIKE '%tickit%' ORDER BY object_name LIMIT 5; share_type | share_name | object_type | object_name ------------+--------------------+-------------+--------------------------------- OUTBOUND | tickit_datashare | table | public.tickit_category_redshift OUTBOUND | tickit_datashare | table | public.tickit_date_redshift OUTBOUND | tickit_datashare | table | public.tickit_event_redshift OUTBOUND | tickit_datashare | table | public.tickit_listing_redshift OUTBOUND | tickit_datashare | table | public.tickit_sales_redshift ``` ``` SELECT * FROM SVV_DATASHARE_OBJECTS WHERE share_name like 'sales%'; share_type | share_name | object_type | object_name | producer_account | producer_namespace | include_new -----------+------------+-------------+--------------+------------------+--------------------------------------+------------- OUTBOUND | salesshare | schema | public | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | t OUTBOUND | salesshare | table | public.sales | 123456789012 | 13b8833d-17c6-4f16-8fe4-1a018f5ed00d | ``` # SVV\$1DEFAULT\$1PRIVILEGES SVV\$1DEFAULT\$1PRIVILEGES Utilice SVV\$1DEFAULT\$1PRIVILEGES para ver los privilegios predeterminados a los que tiene acceso un usuario en un clúster de Amazon Redshift. SVV\$1DEFAULT\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver los permisos predeterminados que se les concedan. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DEFAULT_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo se devuelve la salida para SVV\$1DEFAULT\$1PRIVILEGES. ``` SELECT * from svv_default_privileges; schema_name | object_type | owner_id | owner_name | owner_type | privilege_type | grantee_id | grantee_name | grantee_type | admin_option -------------+-------------------+--------- +------------+------------+----------------+------------+--------------+--------------+-------------+ public | RELATION | 106 | u1 | user | UPDATE | 107 | u2 | user | f | public | RELATION | 106 | u1 | user | SELECT | 107 | u2 | user | f | ``` # SVV\$1DISKUSAGE SVV\$1DISKUSAGE Amazon Redshift crea la vista de sistema SVV\$1DISKUSAGE mediante la combinación de las tablas STV\$1TBL\$1PERM y STV\$1BLOCKLIST. La vista SVV\$1DISKUSAGE tiene información relacionada con la asignación de datos para las tablas en una base de datos. Utilice consultas de agregación con SVV\$1DISKUSAGE, como se muestra en los siguientes ejemplos, para determinar la cantidad de bloques de disco asignados a cada base de datos, tabla, sector o columna. Cada bloque de datos utiliza 1 MB. También puede utilizar [STV\$1PARTITIONS](r_STV_PARTITIONS.md) para obtener información resumida acerca de la utilización del disco. Solo los superusuarios pueden ver SVV\$1DISKUSAGE. 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** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_DISKUSAGE.html) ## Consultas de ejemplo Consultas de ejemplo SVV\$1DISKUSAGE tiene una fila por cada bloque del disco designado, por lo que una consulta que selecciona todas las filas posiblemente devuelva una gran cantidad de filas. Le recomendamos usar solo las consultas de agregación con SVV\$1DISKUSAGE. Devuelve la mayor cantidad de bloques que alguna vez se asignaron a la columna 6 en la tabla USERS (la columna EMAIL): ``` select db_id, trim(name) as tablename, max(blocknum) from svv_diskusage where name='users' and col=6 group by db_id, name; db_id | tablename | max --------+-----------+----- 175857 | users | 2 (1 row) ``` La siguiente consulta devuelve resultados similares para todas las columnas en una tabla grande de 10 columnas llamada SALESNEW. (Las últimas tres filas, para las columnas de la 10 a la 12, son para las columnas ocultas de metadatos). ``` select db_id, trim(name) as tablename, col, tbl, max(blocknum) from svv_diskusage where name='salesnew' group by db_id, name, col, tbl order by db_id, name, col, tbl; db_id | tablename | col | tbl | max --------+------------+-----+--------+----- 175857 | salesnew | 0 | 187605 | 154 175857 | salesnew | 1 | 187605 | 154 175857 | salesnew | 2 | 187605 | 154 175857 | salesnew | 3 | 187605 | 154 175857 | salesnew | 4 | 187605 | 154 175857 | salesnew | 5 | 187605 | 79 175857 | salesnew | 6 | 187605 | 79 175857 | salesnew | 7 | 187605 | 302 175857 | salesnew | 8 | 187605 | 302 175857 | salesnew | 9 | 187605 | 302 175857 | salesnew | 10 | 187605 | 3 175857 | salesnew | 11 | 187605 | 2 175857 | salesnew | 12 | 187605 | 296 (13 rows) ``` # SVV\$1EXTERNAL\$1COLUMNS SVV\$1EXTERNAL\$1COLUMNS Utilice SVV\$1EXTERNAL\$1COLUMNS para ver los detalles de las columnas en las tablas externas. Además, utilice SVV\$1EXTERNAL\$1COLUMNS para consultas entre bases de datos con el fin de ver detalles de todas las columnas de la tabla en bases de datos no conectadas a las que los usuarios tienen acceso. SVV\$1EXTERNAL\$1COLUMNS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_EXTERNAL_COLUMNS.html) # SVV\$1EXTERNAL\$1DATABASES SVV\$1EXTERNAL\$1DATABASES Utilice SVV\$1EXTERNAL\$1DATABASES para ver los detalles de las bases de datos externas. SVV\$1EXTERNAL\$1DATABASES 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_EXTERNAL_DATABASES.html) # SVV\$1EXTERNAL\$1PARTITIONS SVV\$1EXTERNAL\$1PARTITIONS Utilice SVV\$1EXTERNAL\$1PARTITIONS para ver los detalles de las particiones en las tablas externas. SVV\$1EXTERNAL\$1PARTITIONS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_EXTERNAL_PARTITIONS.html) # SVV\$1EXTERNAL\$1SCHEMAS SVV\$1EXTERNAL\$1SCHEMAS Utilice SVV\$1EXTERNAL\$1SCHEMAS para ver información acerca de los esquemas externos. Para obtener más información, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md). SVV\$1EXTERNAL\$1SCHEMAS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_EXTERNAL_SCHEMAS.html) ## Ejemplo Ejemplo En el siguiente ejemplo, se muestran detalles de esquemas externos. ``` select * from svv_external_schemas; esoid | eskind | schemaname | esowner | databasename | esoptions -------+--------+------------+---------+--------------+------------------------------------------------------------- 100133 | 1 | spectrum | 100 | redshift | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} ``` # SVV\$1EXTERNAL\$1TABLES SVV\$1EXTERNAL\$1TABLES Utilice SVV\$1EXTERNAL\$1TABLES para ver los detalles de las tablas externas. Para obtener más información, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md). Además, utilice SVV\$1EXTERNAL\$1TABLES para consultas entre bases de datos con el fin de ver metadatos en todas las tablas de bases de datos no conectadas a las que los usuarios tienen acceso. SVV\$1EXTERNAL\$1TABLES 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_EXTERNAL_TABLES.html) ## Ejemplo Ejemplo El siguiente ejemplo muestra detalles svv\$1external\$1tables con un predicado en el esquema externo utilizado por una consulta federada. ``` select schemaname, tablename from svv_external_tables where schemaname = 'apg_tpch'; schemaname | tablename ------------+----------- apg_tpch | customer apg_tpch | lineitem apg_tpch | nation apg_tpch | orders apg_tpch | part apg_tpch | partsupp apg_tpch | region apg_tpch | supplier (8 rows) ``` # SVV\$1FUNCTION\$1PRIVILEGES SVV\$1FUNCTION\$1PRIVILEGES Utilice SVV\$1FUNCTION\$1PRIVILEGES para ver los permisos de función que tienen concedidos de forma explícita los usuarios, roles y grupos de la base de datos actual. SVV\$1FUNCTION\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_FUNCTION_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1FUNCTION\$1PRIVILEGES. ``` SELECT namespace_name,function_name,argument_types,privilege_type,identity_name,identity_type,admin_option FROM svv_function_privileges WHERE identity_name IN ('role1', 'reguser'); namespace_name | function_name | argument_types | privilege_type | identity_name | identity_type | admin_option ----------------+---------------+----------------------------+----------------+----------------+---------------+-------------- public | test_func1 | integer | EXECUTE | role1 | role | False public | test_func2 | integer, character varying | EXECUTE | reguser | user | False ``` # SVV\$1GEOGRAPHY\$1COLUMNS SVV\$1GEOGRAPHY\$1COLUMNS Utilice SVV\$1GEOGRAPHY\$1COLUMNS para ver la lista de columnas GEOGRAPHY en el almacenamiento de datos. Esta lista de columnas incluye columnas de recursos compartidos de datos. SVV\$1GEOGRAPHY\$1COLUMNS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_GEOGRAPHY_COLUMNS.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo se muestra el resultado de SVV\$1GEOGRAPHY\$1COLUMNS. ``` SELECT * FROM svv_geography_columns; f_table_catalog | f_table_schema | f_table_name | f_geography_column | coord_dimension | srid | type -----------------+-----------------+---------------+---------------------+-----------------+------+-------------- dev | public | spatial_test | test_geography | 2 | 0 | GEOGRAPHY ``` # SVV\$1GEOMETRY\$1COLUMNS SVV\$1GEOMETRY\$1COLUMNS Utilice SVV\$1GEOMETRY\$1COLUMNS para ver la lista de columnas GEOMETRY en el almacenamiento de datos. Esta lista de columnas incluye columnas de recursos compartidos de datos. SVV\$1GEOMETRY\$1COLUMNS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_GEOMETRY_COLUMNS.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo se muestra el resultado de SVV\$1GEOMETRY\$1COLUMNS. ``` SELECT * FROM svv_geometry_columns; f_table_catalog | f_table_schema | f_table_name | f_geometry_column | coord_dimension | srid | type -----------------+-----------------+---------------+---------------------+-----------------+------+-------------- dev | public | accomodations | shape | 2 | 0 | GEOMETRY dev | public | zipcode | wkb_geometry | 2 | 0 | GEOMETRY ``` # SVV\$1IAM\$1PRIVILEGES SVV\$1IAM\$1PRIVILEGES Utilice SVV\$1IAM\$1PRIVILEGES para ver los privilegios de IAM concedidos explícitamente a usuarios, roles y grupos. SVV\$1IAM\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las entradas a las que tienen acceso. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_IAM_PRIVILEGES.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo se muestran los resultados de SVV\$1IAM\$1PRIVILEGES. ``` SELECT * from SVV_IAM_PRIVILEGES ORDER BY IDENTITY_ID; iam_arn | command_type | identity_id | identity_name | identity_type ----------------------+--------------+-------------+---------------+--------------- default-aws-iam-role | COPY | 0 | public | public default-aws-iam-role | UNLOAD | 0 | public | public default-aws-iam-role | CREATE MODEL | 0 | public | public default-aws-iam-role | EXFUNC | 0 | public | public default-aws-iam-role | COPY | 106 | u1 | user default-aws-iam-role | UNLOAD | 106 | u1 | user default-aws-iam-role | CREATE MODEL | 106 | u1 | user default-aws-iam-role | EXFUNC | 106 | u1 | user default-aws-iam-role | COPY | 118413 | r1 | role default-aws-iam-role | UNLOAD | 118413 | r1 | role default-aws-iam-role | CREATE MODEL | 118413 | r1 | role default-aws-iam-role | EXFUNC | 118413 | r1 | role (12 rows) ``` # SVV\$1IDENTITY\$1PROVIDERS SVV\$1IDENTITY\$1PROVIDERS La vista de SVV\$1IDENTITY\$1PROVIDERS devuelve el nombre y las propiedades adicionales de los proveedores de identidades. Para obtener más información sobre cómo crear un proveedor de identidades, consulte [CREATE IDENTITY PROVIDER](r_CREATE_IDENTITY_PROVIDER.md). SVV\$1IDENTITY\$1PROVIDERS 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_SVV_IDENTITY_PROVIDERS.html) ### Consultas de ejemplo Consultas de ejemplo Para ver las propiedades del proveedor de identidades, ejecute una consulta como la siguiente después de crear los proveedores de identidades. ``` SELECT name, type, instanceid, namespc, params, enabled FROM svv_identity_providers ORDER BY 1; ``` El resultado de ejemplo incluye descripciones de parámetros para Microsoft Entra ID (anteriormente Azure AD): ``` name | type | instanceid | namespc | params | enabled ------------------+-------+--------------------------------------+---------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------- rs5517_azure_idp | azure | e40d4bb2-7670-44ae-bfb8-5db013221d73 | abc | {"issuer":"https://login.microsoftonline.com/e40d4bb2-7670-44ae-bfb8-5db013221d73/v2.0", "client_id":"871c010f-5e61-4fb1-83ac-98610a7e9110", "client_secret":, "audience":["https://analysis.windows.net/powerbi/connector/AmazonRedshift", "https://analysis.windows.net/powerbi/connector/AWSRDS"]} | t (1 row) ``` El resultado de ejemplo incluye descripciones de parámetros para AWS IAM Identity Center: ``` name | type | instanceid | namespc | params | enabled ----------+--------+------------------------------------------------------------------------------------+------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------+--------- idc_name | awsidc | arn:aws:sso::123456789012:application/ssoins-12345f67fe123d4/apl-a0b0a12dc123b1a4 | idc_namespc | {"iam_role":"arn:aws:iam::123456789012:role/MyRedshiftRole","instance_arn":"arn:aws:sso:::instance/ssoins-12345f67fe123d4","is_lakehouse_app":"true"} | t (1 row) ``` # SVV\$1INTEGRATION SVV\$1INTEGRATION SVV\$1INTEGRATION muestra detalles sobre la configuración de las integraciones. SVV\$1INTEGRATION 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). Para obtener información sobre las integraciones sin ETL, consulte [Zero-ETL integrations](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_INTEGRATION.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando SQL muestra las integraciones definidas actualmente. ``` select * from svv_integration; integration_id | target_database | source | state | current_lag | last_replicated_checkpoint | total_tables_replicated | total_tables_failed | creation_time | refresh_interval | source_database | is_history_mode ---------------------------------------+-----------------+--------+-----------------+-------------+-------------------------------------+-------------------------+---------------------+---------------------------+--------------------+-----------------+----------------- 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | MySQL | CdcRefreshState | 56606106 | {"txn_seq":9834,"txn_id":126597515} | 152 | 0 | 2023-09-19 21:05:27.520299| 720 + mysourceetl | f ``` # SVV\$1INTEGRATION\$1TABLE\$1MAPPING SVV\$1INTEGRATION\$1TABLE\$1MAPPING SVV\$1INTEGRATION\$1TABLE\$1MAPPING muestra la asignación de la base de datos, el esquema, la tabla, la columna y el tipo de datos del origen al destino cuando el valor identificador de esos campos sea diferente. **nota** Esta vista solo se rellena para los siguientes tipos de integraciones sin ETL: Aplicaciones de terceros de AWS Glue a Amazon SageMaker Lakehouse Amazon DynamoDB a Amazon SageMaker Lakehouse Para obtener más información, consulte [Zero-ETL integrations](https://docs.aws.amazon.com/glue/latest/dg/zero-etl-using.html) en la *Guía para desarrolladores de AWS Glue.* La transformación de los valores de los identificadores del origen al destino sigue estas reglas: + Una letra mayúscula se convierte en minúscula. + Un carácter que no sea una letra minúscula, un dígito o un guion bajo (\$1) se convierte en un carácter de subrayado (\$1). + Si hay un conflicto con un valor de identificador existente, se añade un identificador único universal (UUID) al nuevo identificador. + Si el valor del identificador de origen es una palabra clave de Amazon Redshift, el sufijo `_redshift` se añade al nuevo identificador. Tras la transformación, un carácter debe ser una letra minúscula, un dígito o un guion bajo (\$1) y coincidir con el patrón de expresiones regex `[a-z0-9_]`. Los siguientes ejemplos muestran las reglas de conversión: | Origen | Destino | Notas | | --- | --- | --- | | foo | foo | Sin transformación | | Barras | barra | | | fooBar | foobar | | | foo1 | foo1 | Sin transformación | | foo\$11 | foo\$11 | Sin transformación | | Bar @1 | bar\$11 | | | foo\$1bar@ | foo\$1bar\$1 | | | caso | case\$1redshift | | SVV\$1INTEGRATION\$1TABLE\$1MAPPING 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). Para obtener información sobre las integraciones sin ETL, consulte [Zero-ETL integrations](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html) en la *Guía de administración de Amazon Redshift*. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_MAPPING.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando SQL muestra la asignación de valores de metadatos del origen al destino. ``` select * from svv_integration_table_mapping; integration_id | source_database | target_database | source_schema_name | target_schema_name | source_table_name | target_table_name | ---------------------------------------+-----------------+-----------------+---------------------+--------------------+---------------------------------------+ 99108e72-1cfd-414f-8cc0-0216acefac77 | mydatabase | mydatabase | myschema | myschema | Mytable | mytable | | source_column_name | target_column_name | source_data_type | target_data_type | +--------------------+--------------------+-------------------+------------------+ | Mycolumnname | mycolumnname | Mydatatype | mydatatype | ``` # SVV\$1INTEGRATION\$1TABLE\$1STATE SVV\$1INTEGRATION\$1TABLE\$1STATE SVV\$1INTEGRATION\$1TABLE\$1STATE muestra detalles sobre la información de integración en el nivel de tabla. SVV\$1INTEGRATION\$1TABLE\$1STATE solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Para obtener más información, consulte [Integraciones sin ETL](https://docs.aws.amazon.com/redshift/latest/mgmt/zero-etl-using.html). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_INTEGRATION_TABLE_STATE.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando de SQL muestra las columnas del registro de las integraciones. ``` select * from svv_integration_table_state; integration_id | target_database | schema_name | table_name | table_state |table_last_replicated_checkpoint | reason | last_updated_timestamp |table_rows | table_size | is_history_mode --------------------------------------+-----------------+-------------+-------------------+--------------+---------------------------------+--------+----------------------------+------------+------------+----------------- 4798e675-8f9f-4686-b05f-92c538e19629 | sample_test2 | sample | SampleTestChannel | Synced | {"txn_seq":3,"txn_id":3122} | | 2023-05-12 12:40:30.656625 | 2 | 16 | f ``` # SVV\$1INTERLEAVED\$1COLUMNS SVV\$1INTERLEAVED\$1COLUMNS Utilice la vista SVV\$1INTERLEAVED\$1COLUMNS para identificar, de manera más fácil, si una tabla que utiliza claves de ordenación con intervalos debería volver a indizarse utilizando un comando [VACUUM REINDEX](r_VACUUM_command.md#vacuum-reindex). Para obtener más información acerca de cómo determinar con qué frecuencia ejecutar el comando VACUUM y cuándo ejecutar el comando VACUUM REINDEX, consulte [Cómo minimizar los tiempos de limpieza](vacuum-managing-vacuum-times.md). Solo los superusuarios pueden ver SVV\$1INTERLEAVED\$1COLUMNS. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_INTERLEAVED_COLUMNS.html) ## Consultas de ejemplo Consultas de ejemplo Para identificar las tablas que podrían necesitar volver a indexarse, ejecute la siguiente consulta. ``` select tbl as tbl_id, stv_tbl_perm.name as table_name, col, interleaved_skew, last_reindex from svv_interleaved_columns, stv_tbl_perm where svv_interleaved_columns.tbl = stv_tbl_perm.id and interleaved_skew is not null; tbl_id | table_name | col | interleaved_skew | last_reindex --------+------------+-----+------------------+-------------------- 100068 | lineorder | 0 | 3.65 | 2015-04-22 22:05:45 100068 | lineorder | 1 | 2.65 | 2015-04-22 22:05:45 100072 | customer | 0 | 1.65 | 2015-04-22 22:05:45 100072 | lineorder | 1 | 1.00 | 2015-04-22 22:05:45 (4 rows) ``` # SVV\$1LANGUAGE\$1PRIVILEGES SVV\$1LANGUAGE\$1PRIVILEGES Utilice SVV\$1LANGUAGE\$1PRIVILEGES para ver los permisos de lenguaje que tienen concedidos de forma explícita los usuarios, roles y grupos de la base de datos actual. SVV\$1LANGUAGE\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_LANUGAGE_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1LANGUAGE\$1PRIVILEGES. ``` SELECT language_name,privilege_type,identity_name,identity_type,admin_option FROM svv_language_privileges WHERE identity_name IN ('role1', 'reguser'); language_name | privilege_type | identity_name | identity_type | admin_option ---------------+----------------+---------------+---------------+--------------- exfunc | USAGE | reguser | user | False exfunc | USAGE | role1 | role | False plpythonu | USAGE | reguser | user | False ``` # SVV\$1MASKING\$1POLICY SVV\$1MASKING\$1POLICY Utilice SVV\$1MASKING\$1POLICY para ver todas las políticas de enmascaramiento creadas en el clúster. Solo los superusuarios y los usuarios con el rol [https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html](https://docs.aws.amazon.com/redshift/latest/dg/r_roles-default.html) pueden ver SVV\$1MASKING\$1POLICY. Los usuarios normales verán 0 filas. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_MASKING_POLICY.html) # SVV\$1ML\$1MODEL\$1INFO SVV\$1ML\$1MODEL\$1INFO Información acerca del estado actual del modelo de machine learning. SVV\$1ML\$1MODEL\$1INFO es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ML_MODEL_INFO.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el estado actual de los modelos de machine learning. ``` SELECT schema_name, model_name, model_state FROM svv_ml_model_info; schema_name | model_name | model_state -------------+------------------------------+-------------------------------------- public | customer_churn_auto_model | Train Model On SageMaker In Progress public | customer_churn_xgboost_model | Model is Ready (2 row) ``` # SVV\$1ML\$1MODEL\$1PRIVILEGES SVV\$1ML\$1MODEL\$1PRIVILEGES Utilice SVV\$1ML\$1MODEL\$1PRIVILEGES para ver los permisos de modelo de machine learning que tienen concedidos de forma explícita los usuarios, roles y grupos del clúster. SVV\$1ML\$1MODEL\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ML_MODEL_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1ML\$1MODEL\$1PRIVILEGES. ``` SELECT namespace_name,model_name,model_version,privilege_type,identity_name,identity_type,admin_option FROM svv_ml_model_privileges WHERE model_name = 'test_model'; namespace_name | model_name | model_version | privilege_type | identity_name | identity_type | admin_option ----------------+------------+---------------+----------------+----------------+---------------+-------------- public | test_model | 1 | EXECUTE | reguser | user | False public | test_model | 1 | EXECUTE | role1 | role | False ``` # SVV\$1MV\$1DEPENDENCY SVV\$1MV\$1DEPENDENCY En la tabla SVV\$1MV\$1DEPENDENCY, se muestran las dependencias de vistas materializadas con respecto a otras vistas materializadas de Amazon Redshift. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). SVV\$1MV\$1DEPENDENCY 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_MV_DEPENDENCY.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve una fila de salida que indica que la vista materializada `mv_over_foo` utiliza la vista materializada `mv_foo` en su definición como una dependencia. ``` CREATE SCHEMA test_ivm_setup; CREATE TABLE test_ivm_setup.foo(a INT); CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo; CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo; SELECT * FROM svv_mv_dependency; database_name | schema_name | name | dependent_database_name | dependent_schema_name | dependent_name ---------------+----------------------+-------------+-------------------------+---------------------------+---------- dev | test_ivm_setup | mv_over_foo | dev | test_ivm_setup | mv_foo ``` # SVV\$1MV\$1INFO SVV\$1MV\$1INFO La tabla SVV\$1MV\$1INFO contiene una fila para cada vista materializada, si los datos están o no obsoletos e información de estado. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). Todos los usuarios pueden ver SVV\$1MV\$1INFO. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_MV_INFO.html) ## Consulta de ejemplo Consulta de ejemplo Para ver el estado de todas las vistas materializadas, ejecute la siguiente consulta. ``` select * from svv_mv_info; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` database_name | schema_name | user_name | name | is_stale | state | autorefresh | autorewrite --------------+-------------------------+-----------+---------+-----------+-------+-------------+---------------- dev | test_ivm_setup | catch-22 | mv | f | 1 | 1 | 0 dev | test_ivm_setup | lotr | old_mv | t | 1 | 0 | 1 ``` # SVV\$1QUERY\$1INFLIGHT SVV\$1QUERY\$1INFLIGHT Utilice la vista SVV\$1QUERY\$1INFLIGHT para determinar cuáles son las consultas que se están ejecutando actualmente en la base de datos. La vista combina [STV\$1INFLIGHT](r_STV_INFLIGHT.md) con [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md). SVV\$1QUERY\$1INFLIGHT no muestra las consultas únicas del nodo principal. Para obtener más información, consulte [Funciones específicas del nodo principal](c_SQL_functions_leader_node_only.md). SVV\$1QUERY\$1INFLIGHT 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** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_QUERY_INFLIGHT.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo de salida, se muestran dos consultas que están actualmente en ejecución, incluida la misma consulta SVV\$1QUERY\$1INFLIGHT y la consulta 428, que está dividida en tres filas en la tabla. (En este ejemplo de salida, las columnas starttime y statement están truncadas). ``` select slice, query, pid, starttime, suspended, trim(text) as statement, sequence from svv_query_inflight order by query, sequence; slice|query| pid | starttime |suspended| statement | sequence -----+-----+------+----------------------+---------+-----------+--------- 1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | select ...| 0 1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | enueid ...| 1 1012 | 428 | 1658 | 2012-04-10 13:53:... | 0 | atname,...| 2 1012 | 429 | 1608 | 2012-04-10 13:53:... | 0 | select ...| 0 (4 rows) ``` # SVV\$1QUERY\$1STATE SVV\$1QUERY\$1STATE Utilice SVV\$1QUERY\$1STATE para ver información sobre el tiempo de ejecución de las consultas en ejecución actualmente. La vista SVV\$1QUERY\$1STATE tiene un subconjunto de datos de la tabla STV\$1EXEC\$1STATE. SVV\$1QUERY\$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\$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. **nota** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_QUERY_STATE.html) ## Consultas de ejemplo Consultas de ejemplo **Determinar cuál es el tiempo de procesamiento de una consulta en cada paso** En la siguiente consulta, se muestra cuánto tiempo demoró en ejecutarse cada paso de la consulta con el ID de consulta 279 y cuántas filas de datos procesó Amazon Redshift: ``` select query, seg, step, maxtime, avgtime, rows, label from svv_query_state where query = 279 order by query, seg, step; ``` Esta consulta recupera la información de procesamiento acerca de la consulta 279, tal como se muestra en el siguiente ejemplo de salida: ``` query | seg | step | maxtime | avgtime | rows | label ------+---------+------+---------+---------+---------+------------------- 279 | 3 | 0 | 1658054 | 1645711 | 1405360 | scan 279 | 3 | 1 | 1658072 | 1645809 | 0 | project 279 | 3 | 2 | 1658074 | 1645812 | 1405434 | insert 279 | 3 | 3 | 1658080 | 1645816 | 1405437 | distribute 279 | 4 | 0 | 1677443 | 1666189 | 1268431 | scan 279 | 4 | 1 | 1677446 | 1666192 | 1268434 | insert 279 | 4 | 2 | 1677451 | 1666195 | 0 | aggr (7 rows) ``` **Determinar qué consultas activas se están ejecutando actualmente en el disco** En la siguiente consulta, se muestra si alguna de las consultas activas se está ejecutando actualmente en el disco: ``` select query, label, is_diskbased from svv_query_state where is_diskbased = 't'; ``` En este ejemplo de salida, se muestra si alguna de las consultas activas se está ejecutando actualmente en el disco: ``` query | label | is_diskbased -------+--------------+-------------- 1025 | hash tbl=142 | t (1 row) ``` # SVV\$1REDSHIFT\$1COLUMNS SVV\$1REDSHIFT\$1COLUMNS Utilice SVV\$1REDSHIFT\$1COLUMNS para ver una lista de todas las columnas a las que tiene acceso un usuario. Este conjunto de columnas incluye las columnas del clúster y las columnas de los datashares proporcionados por los clústeres remotos. SVV\$1REDSHIFT\$1COLUMNS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_COLUMNS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1REDSHIFT\$1COLUMNS. ``` SELECT * FROM svv_redshift_columns WHERE database_name = 'tickit_db' AND TABLE_NAME = 'tickit_sales_redshift' ORDER BY COLUMN_NAME, TABLE_NAME, database_name LIMIT 5; database_name | schema_name | table_name | column_name | ordinal_position | data_type | column_default | is_nullable | encoding | distkey | sortkey | column_acl | remarks --------------+-------------+-----------------------+-------------+------------------+-----------+----------------+-------------+----------+---------+---------+-------------+-------- tickit_db | public | tickit_sales_redshift | buyerid | 4 | integer | | NO | az64 | False | 0 | | tickit_db | public | tickit_sales_redshift | commission | 9 | numeric | (8,2) | YES | az64 | False | 0 | | tickit_db | public | tickit_sales_redshift | dateid | 6 | smallint | | NO | none | False | 1 | | tickit_db | public | tickit_sales_redshift | eventid | 5 | integer | | NO | az64 | False | 0 | | tickit_db | public | tickit_sales_redshift | listid | 2 | integer | | NO | az64 | True | 0 | | ``` # SVV\$1REDSHIFT\$1DATABASES SVV\$1REDSHIFT\$1DATABASES Utilice SVV\$1REDSHIFT\$1DATABASES para ver una lista de todas las bases de datos a las que tiene acceso un usuario. Esto incluye las bases de datos del clúster y las bases de datos creadas a partir de datashares proporcionados por clústeres remotos. SVV\$1REDSHIFT\$1DATABASES es visible para todos los usuarios de forma predeterminada. Para controlar el acceso a los metadatos de la base de datos, habilite la seguridad de los metadatos para el clúster aprovisionado o el grupo de trabajo sin servidor. La seguridad de los metadatos le permite separar los permisos de visualización de los metadatos de los objetos por usuarios y roles. Para obtener más información, consulte [Seguridad de los metadatos](t_metadata_security.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_DATABASES.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1REDSHIFT\$1DATABASES. ``` select database_name, database_owner, database_type, database_options, database_isolation_level from svv_redshift_databases; database_name | database_owner | database_type | database_options | database_isolation_level --------------+----------------+---------------+------------------+------------------ dev | 1 | local | NULL | Serializable ``` # SVV\$1REDSHIFT\$1FUNCTIONS SVV\$1REDSHIFT\$1FUNCTIONS Utilice SVV\$1REDSHIFT\$1FUNCTIONS para ver una lista de todas las funciones a las que tiene acceso un usuario. Este conjunto de funciones incluye las funciones del clúster y las funciones de los datashares proporcionados por los clústeres remotos. SVV\$1REDSHIFT\$1FUNCTIONS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_FUNCTIONS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1REDSHIFT\$1FUNCTIONS. ``` SELECT * FROM svv_redshift_functions WHERE database_name = 'tickit_db' AND SCHEMA_NAME = 'public' ORDER BY function_name LIMIT 5; database_name | schema_name | function_name | function_type | argument_type | result_type --------------+-------------+-----------------------+------------------+------------------+------------- tickit_db | public | shared_function | REGULAR FUNCTION | integer, integer | integer ``` # SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA Muestra la cuota y la utilización actual del disco para cada esquema de una base de datos. SVV\$1REDSHIFT\$1SCHEMA\$1QUOTA 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). Esta vista está disponible cuando se consultan clústeres aprovisionados o grupos de trabajo de Redshift sin servidor. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMA_QUOTA.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra la cuota y el uso de disco actual para el esquema denominado `sales_schema`. ``` SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage FROM svv_redshift_schema_quota WHERE SCHEMA_NAME = 'sales_schema'; schema_name | quota | disk_usage --------------+-------+------------ sales_schema | 2048 | 30 ``` # SVV\$1REDSHIFT\$1SCHEMAS SVV\$1REDSHIFT\$1SCHEMAS Utilice SVV\$1REDSHIFT\$1SCHEMAS para ver una lista de todos los esquemas a los que tiene acceso un usuario. Este conjunto de esquemas incluye los esquemas del clúster y los esquemas de los datashares proporcionados por clústeres remotos. SVV\$1REDSHIFT\$1SCHEMAS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_SCHEMAS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1REDSHIFT\$1SCHEMAS. ``` SELECT * FROM svv_redshift_schemas WHERE database_name = 'tickit_db' ORDER BY database_name, SCHEMA_NAME; database_name | schema_name | schema_owner | schema_type | schema_acl | schema_option --------------+--------------------+--------------+-------------+------------+--------------- tickit_db | public | 1 | shared | | ``` # SVV\$1REDSHIFT\$1TABLES SVV\$1REDSHIFT\$1TABLES Utilice SVV\$1REDSHIFT\$1TABLES para ver una lista de todas las tablas a las que tiene acceso un usuario. Este conjunto de tablas incluye las tablas del clúster y las tablas de los datashares proporcionados por los clústeres remotos. SVV\$1REDSHIFT\$1TABLES 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_REDSHIFT_TABLES.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1REDSHIFT\$1TABLES. ``` SELECT * FROM svv_redshift_tables WHERE database_name = 'tickit_db' AND TABLE_NAME LIKE 'tickit_%' ORDER BY database_name, TABLE_NAME; database_name | schema_name | table_name | table_type | table_acl | remarks | table_owner --------------+-------------+--------------------------+------------+-----------+---------+----------- tickit_db | public | tickit_category_redshift | TABLE | | + tickit_db | public | tickit_date_redshift | TABLE | | + tickit_db | public | tickit_event_redshift | TABLE | | + tickit_db | public | tickit_listing_redshift | TABLE | | + tickit_db | public | tickit_sales_redshift | TABLE | | + tickit_db | public | tickit_users_redshift | TABLE | | + tickit_db | public | tickit_venue_redshift | TABLE | | ``` Si el valor de table\$1acl es nulo, no se han concedido explícitamente privilegios de acceso a la tabla correspondiente. # SVV\$1RELATION\$1PRIVILEGES SVV\$1RELATION\$1PRIVILEGES Utilice SVV\$1RELATION\$1PRIVILEGES para ver los permisos de relación (tablas y vistas) que tienen concedidos de forma explícita a los usuarios, roles y grupos de la base de datos actual. SVV\$1RELATION\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso SYSLOG ACCESS UNRESTRICTED Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. Para obtener más información acerca de la visibilidad de datos, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_RELATION_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1RELATION\$1PRIVILEGES. ``` SELECT namespace_name,relation_name,privilege_type,identity_name,identity_type,admin_option FROM svv_relation_privileges WHERE relation_name = 'orders' AND privilege_type = 'SELECT'; namespace_name | relation_name | privilege_type | identity_name | identity_type | admin_option ----------------+---------------+----------------+----------------+---------------+-------------- public | orders | SELECT | reguser | user | False public | orders | SELECT | role1 | role | False ``` # SVV\$1RLS\$1APPLIED\$1POLICY SVV\$1RLS\$1APPLIED\$1POLICY Utilice SVV\$1RLS\$1APPLIED\$1POLICY para rastrear la aplicación de políticas de RLS en consultas que hacen referencia a relaciones protegidas por RLS. SVV\$1RLS\$1APPLIED\$1POLICY es visible para los usuarios siguientes: + Superusuarios + Usuarios con el rol `sys:operator` + Usuarios con el permiso ACCESS SYSTEM TABLE Tenga en cuenta que sys:secadmin no tiene este permiso del sistema. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_RLS_APPLIED_POLICY.html) ## Consulta de ejemplo Consulta de ejemplo En el ejemplo siguiente, se muestra el resultado de SVV\$1RLS\$1APPLIED\$1POLICY. Para consultar SVV\$1RLS\$1APPLIED\$1POLICY, debe contar con el permiso ACCESS SYSTEM TABLE. ``` -- Check what RLS policies were applied to the run query. SELECT username, command, datname, relschema, relname, polname, poldefault FROM svv_rls_applied_policy WHERE datname = CURRENT_DATABASE() AND query = PG_LAST_QUERY_ID(); username | command | datname | relschema | relname | polname | poldefault ----------+---------+-----------+-----------+--------------------------+-----------------+------------ molly | s | tickit_db | public | tickit_category_redshift | policy_concerts | ``` # SVV\$1RLS\$1ATTACHED\$1POLICY SVV\$1RLS\$1ATTACHED\$1POLICY Utilice SVV\$1RLS\$1ATTACHED\$1POLICY para ver una lista de todas las relaciones y los usuarios que tienen una o más políticas de seguridad de la fila adjuntas a la base de datos conectada actualmente. Solo los usuarios con el rol sys:secadmin pueden consultar esta vista. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_RLS_ATTACHED_POLICY.html) ## Consulta de ejemplo Consulta de ejemplo En el ejemplo siguiente, se muestra el resultado de SVV\$1RLS\$1ATTACHED\$1POLICY. ``` --Inspect the policy in SVV_RLS_ATTACHED_POLICY SELECT * FROM svv_rls_attached_policy; relschema | relname | relkind | polname | grantor | grantee | granteekind | is_pol_on | is_rls_on | rls_conjuntion_type -----------+--------------------------+---------+-----------------+---------+----------+-------------+-----------+-----------+--------------------- public | tickit_category_redshift | table | policy_concerts | bob | analyst | role | True | True | and public | tickit_category_redshift | table | policy_concerts | bob | dbadmin | role | True | True | and ``` # SVV\$1RLS\$1POLICY SVV\$1RLS\$1POLICY Utilice SVV\$1RLS\$1POLICY para ver una lista de todas las políticas de seguridad de la fila creadas en el clúster de Amazon Redshift. SVV\$1RLS\$1POLICY 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_RLS_POLICY.html) ## Consulta de ejemplo Consulta de ejemplo En el ejemplo siguiente, se muestra el resultado de SVV\$1RLS\$1POLICY. ``` -- Create some policies. CREATE RLS POLICY pol1 WITH (a int) AS t USING ( t.a IS NOT NULL ); CREATE RLS POLICY pol2 WITH (c varchar(10)) AS t USING ( c LIKE '%public%'); -- Inspect the policy in SVV_RLS_POLICY SELECT * FROM svv_rls_policy; poldb | polname | polalias | polatts | polqual | polenabled | polmodifiedby | polmodifiedtime -------+---------+----------+--------------------------------------------------+---------------------------------------+------------+---------------+--------------------- my_db | pol1 | t | [{"colname":"a","type":"integer"}] | "t"."a" IS NOT NULL | t | policy_admin | 2022-02-11 14:40:49 my_db | pol2 | t | [{"colname":"c","type":"character varying(10)"}] | "t"."c" LIKE CAST('%public%' AS TEXT) | t | policy_admin | 2022-02-11 14:41:28 ``` # SVV\$1RLS\$1RELATION SVV\$1RLS\$1RELATION Utilice SVV\$1RLS\$1RELATION para ver una lista de todas las relaciones que están protegidas por RLS. SVV\$1RLS\$1RELATION 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_RLS_RELATION.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1RLS\$1RELATION. ``` ALTER TABLE tickit_category_redshift ROW LEVEL SECURITY ON FOR DATASHARES; --Inspect RLS state on the relations using SVV_RLS_RELATION. SELECT datname, relschema, relname, relkind, is_rls_on, is_rls_datashare_on FROM svv_rls_relation ORDER BY relname; datname | relschema | relname | relkind | is_rls_on | is_rls_datashare_on | rls_conjunction_type | rls_datashare_conjunction_type -----------+-----------+--------------------------+---------+-----------+---------------------+----------------------+-------------------------------- tickit_db | public | tickit_category_redshift | table | t | t | and | and (1 row) ``` # SVV\$1ROLE\$1GRANTS SVV\$1ROLE\$1GRANTS Utilice SVV\$1ROLE\$1GRANTS para ver una lista de roles que tienen concedidos roles de forma explícita en el clúster. SVV\$1ROLE\$1GRANTS es visible para los usuarios siguientes: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ROLE_GRANTS.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1ROLE\$1GRANTS. ``` GRANT ROLE role1 TO ROLE role2; GRANT ROLE role2 TO ROLE role3; SELECT role_name, granted_role_name FROM svv_role_grants; role_name | granted_role_name -----------+-------------------- role2 | role1 role3 | role2 (2 rows) ``` # SVV\$1ROLES SVV\$1ROLES Utilice SVV\$1ROLES para ver la información de los roles. Todos los usuarios pueden ver la tabla. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_ROLES.html) ## Consulta de ejemplo Consulta de ejemplo El siguiente ejemplo devuelve el resultado de SVV\$1ROLES. ``` SELECT role_name,role_owner FROM svv_roles WHERE role_name IN ('role1', 'role2'); role_name | role_owner -----------+------------ role1 | superuser role2 | superuser ``` # SVV\$1SCHEMA\$1PRIVILEGES SVV\$1SCHEMA\$1PRIVILEGES Utilice SVV\$1SCHEMA\$1PRIVILEGES para ver los permisos de esquema que tienen concedidos de forma explícita los usuarios, roles y grupos de la base de datos actual. SVV\$1SCHEMA\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_SCHEMA_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de SVV\$1SCHEMA\$1PRIVILEGES. ``` SELECT namespace_name,privilege_type,identity_name,identity_type,admin_option FROM svv_schema_privileges WHERE namespace_name = 'test_schema1'; namespace_name | privilege_type | identity_name | identity_type | admin_option ----------------+----------------+----------------+---------------+-------------- test_schema1 | USAGE | reguser | user | False test_schema1 | USAGE | role1 | role | False ``` # SVV\$1SCHEMA\$1QUOTA\$1STATE SVV\$1SCHEMA\$1QUOTA\$1STATE Muestra la cuota y el uso actual del disco para cada esquema. Los usuarios normales pueden ver información de esquemas para los que tienen permiso de USO. Los superusuarios pueden ver información de todos los esquemas de la base de datos actual. SVV\$1SCHEMA\$1QUOTA\$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). **nota** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_SCHEMA_QUOTA_STATE.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra la cuota y el uso de disco actual para el esquema. ``` SELECT TRIM(SCHEMA_NAME) "schema_name", QUOTA, disk_usage, disk_usage_pct FROM svv_schema_quota_state WHERE SCHEMA_NAME = 'sales_schema'; schema_name | quota | disk_usage | disk_usage_pct --------------+-------+------------+---------------- sales_schema | 2048 | 30 | 1.46 (1 row) ``` # SVV\$1SYSTEM\$1PRIVILEGES SVV\$1SYSTEM\$1PRIVILEGES SVV\$1SYSTEM\$1PRIVILEGES es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver las identidades a las que tienen acceso o que son de su propiedad. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_SYSTEM_PRIVILEGES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se muestra el resultado de los parámetros especificados. ``` SELECT system_privilege,identity_name,identity_type FROM svv_system_privileges WHERE system_privilege = 'ALTER TABLE' AND identity_name = 'sys:superuser'; system_privilege | identity_name | identity_type ------------------+---------------+--------------- ALTER TABLE | sys:superuser | role ``` # SVV\$1TABLE\$1INFO SVV\$1TABLE\$1INFO Muestra información resumida de las tablas y vistas materializadas de la base de datos actualmente conectada. La vista filtra las tablas del sistema y muestra solo las tablas definidas por el usuario y las vistas materializadas que contienen al menos 1 fila de datos. Puede utilizar la vista SVV\$1TABLE\$1INFO para diagnosticar y dar respuesta a problemas de diseño de las tablas que puedan influir en el rendimiento de las consultas. Eso incluye problemas con la codificación de compresión, las claves de distribución, el estilo de ordenación, el sesgo de la distribución de los datos, el tamaño de las tablas y las estadísticas. La vista SVV\$1TABLE\$1INFO no devuelve información para las tablas vacías. La vista SVV\$1TABLE\$1INFO resume la información de las siguientes tablas del sistema y tablas de catálogo: + [STV\$1NODE\$1STORAGE\$1CAPACITY](r_STV_NODE_STORAGE_CAPACITY.md) + [STV\$1SLICES](r_STV_SLICES.md) + [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md) + [PG\$1ATTRIBUTE](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html) + [PG\$1CLASS](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html) + [PG\$1DATABASE](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html) + [PG\$1NAMESPACE](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html) + [PG\$1STATISTIC\$1INDICATOR](r_PG_STATISTIC_INDICATOR.md) Solo los superusuarios pueden ver SVV\$1TABLE\$1INFO. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Para permitir que un usuario pueda consultar la vista, conceda el permiso SELECT en SVV\$1TABLE\$1INFO al usuario. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_TABLE_INFO.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra la codificación, el estilo de distribución, la ordenación y los sesgos de datos para todas las tablas definidas por el usuario en la base de datos. Aquí, "table" se debe indicar entre comillas dobles porque es una palabra reservada. ``` select "table", encoded, diststyle, sortkey1, skew_sortkey1, skew_rows from svv_table_info order by 1; table | encoded | diststyle | sortkey1 | skew_sortkey1 | skew_rows ---------------+---------+-----------------+--------------+---------------+---------- category | N | EVEN | | | date | N | ALL | dateid | 1.00 | event | Y | KEY(eventid) | dateid | 1.00 | 1.02 listing | Y | KEY(listid) | dateid | 1.00 | 1.01 sales | Y | KEY(listid) | dateid | 1.00 | 1.02 users | Y | KEY(userid) | userid | 1.00 | 1.01 venue | N | ALL | venueid | 1.00 | (7 rows) ``` # SVV\$1TABLES SVV\$1TABLES Utilice SVV\$1TABLES para ver las tablas en catálogos locales y externos. SVV\$1TABLES es visible para todos los usuarios de forma predeterminada. Para controlar el acceso a los metadatos de la base de datos, habilite la seguridad de los metadatos para el clúster aprovisionado o el grupo de trabajo sin servidor. La seguridad de los metadatos le permite separar los permisos de visualización de los metadatos de los objetos por usuarios y roles. Para obtener más información, consulte [Seguridad de los metadatos](t_metadata_security.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_TABLES.html) # SVV\$1TRANSACTIONS SVV\$1TRANSACTIONS Registra información acerca de transacciones que actualmente tienen bloqueos en las tablas de la base de datos. Utilice la vista SVV\$1TRANSACTIONS para identificar las transacciones abiertas y bloquear los problemas de contención. Para obtener más información acerca de bloqueos, consulte [Administración de operaciones de escritura simultáneas](c_Concurrent_writes.md) y [LOCK](r_LOCK.md). SVV\$1TRANSACTIONS 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_TRANSACTIONS.html) ## Consultas de ejemplo Consultas de ejemplo Mediante el siguiente comando, se muestran todas las transacciones activas y los bloqueos solicitados por cada transacción. ``` select * from svv_transactions; txn_ lockable_ owner | txn_db | xid | pid | txn_start | lock_mode | object_type | relation | granted -------+--------+--------+-------+----------------------------+---------------------+----------------+----------+--------- root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | AccessShareLock | relation | 100068 | t root | dev | 438484 | 22223 | 2016-03-02 18:42:18.862254 | ExclusiveLock | transactionid | | t root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 50860 | t root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | AccessShareLock | relation | 52310 | t root | tickit | 438490 | 22277 | 2016-03-02 18:42:48.084037 | ExclusiveLock | transactionid | | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100068 | f root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | RowExclusiveLock | relation | 16688 | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessShareLock | relation | 100064 | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100166 | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100171 | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | AccessExclusiveLock | relation | 100190 | t root | dev | 438505 | 22378 | 2016-03-02 18:43:27.611292 | ExclusiveLock | transactionid | | t (12 rows) (12 rows) ``` # SVV\$1USER\$1GRANTS SVV\$1USER\$1GRANTS Utilice SVV\$1USER\$1GRANTS para ver la lista de usuarios que tienen concedidos roles de forma explícita en el clúster. SVV\$1USER\$1GRANTS es visible para los siguientes usuarios: + Superusuarios + Usuarios con el permiso ACCESS SYSTEM TABLE Los demás usuarios solo pueden ver los roles que se les conceden de forma explícita. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_USER_GRANTS.html) ## Consultas de ejemplo Consultas de ejemplo Las siguientes consultas conceden roles a los usuarios y muestran la lista de usuarios que tienen concedidos roles de forma explícita. ``` GRANT ROLE role1 TO reguser; GRANT ROLE role2 TO reguser; GRANT ROLE role1 TO superuser; GRANT ROLE role2 TO superuser; SELECT user_name,role_name,admin_option FROM svv_user_grants; user_name | role_name | admin_option -----------+-----------+-------------- superuser | role1 | False reguser | role1 | False superuser | role2 | False reguser | role2 | False ``` # SVV\$1USER\$1INFO SVV\$1USER\$1INFO Puede recuperar datos sobre los usuarios de la base de datos de Amazon Redshift con la vista SVV\$1USER\$1INFO. SVV\$1USER\$1INFO es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_USER_INFO.html) ## Consultas de ejemplo Consulta de ejemplo El siguiente comando recupera la información del usuario de SVV\$1USER\$1INFO. ``` SELECT * FROM SVV_USER_INFO; ``` # SVV\$1VACUUM\$1PROGRESS SVV\$1VACUUM\$1PROGRESS Esta vista devuelve una estimación de cuánto tiempo demorará en completarse una operación de limpieza que actualmente está en progreso. Solo los superusuarios pueden ver SVV\$1VACUUM\$1PROGRESS. 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. Para obtener más información sobre SVV\$1VACUUM\$1SUMMARY, consulte [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md). Para obtener más información sobre SVL\$1VACUUM\$1PERCENTAGE, consulte [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md). **nota** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_VACUUM_PROGRESS.html) ## Consultas de ejemplo Consultas de ejemplo Las siguientes consultas, ejecutadas con unos pocos minutos de diferencia, muestran que se está limpiando una tabla grande llamada SALESNEW. ``` select * from svv_vacuum_progress; table_name | status | time_remaining_estimate --------------+-------------------------------+------------------------- salesnew | Vacuum: initialize salesnew | (1 row) ... select * from svv_vacuum_progress; table_name | status | time_remaining_estimate -------------+------------------------+------------------------- salesnew | Vacuum salesnew sort | 33m 21s (1 row) ``` La siguiente consulta muestra que actualmente no hay ninguna operación de limpieza en progreso. La última tabla que se limpió fue la tabla SALES. ``` select * from svv_vacuum_progress; table_name | status | time_remaining_estimate -------------+----------+------------------------- sales | Complete | (1 row) ``` # SVV\$1VACUUM\$1SUMMARY SVV\$1VACUUM\$1SUMMARY La vista SVV\$1VACUUM\$1SUMMARY combina las tablas STL\$1VACUUM, STL\$1QUERY y STV\$1TBL\$1PERM para resumir información relacionada con las operaciones de limpieza registradas por el sistema. La vista devuelve una fila por tabla por transacción de limpieza. La vista registra el tiempo transcurrido de la operación, la cantidad de particiones de orden creadas, la cantidad de incrementos de fusión requeridos y los deltas en conteos de fila y bloqueos antes y después de que se realiza la operación. Solo los superusuarios pueden ver SVV\$1VACUUM\$1SUMMARY. 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. Para obtener más información sobre SVV\$1VACUUM\$1PROGRESS, consulte [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md). Para obtener más información sobre SVL\$1VACUUM\$1PERCENTAGE, consulte [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md). **nota** Esta vista solo está disponible cuando se consultan clústeres aprovisionados. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVV_VACUUM_SUMMARY.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve estadísticas para operaciones de limpieza sobre tres tablas diferentes. La tabla SALES se limpió dos veces. ``` select table_name, xid, sort_partitions as parts, merge_increments as merges, elapsed_time, row_delta, sortedrow_delta as sorted_delta, block_delta from svv_vacuum_summary order by xid; table_ | xid |parts|merges| elapsed_ | row_ | sorted_ | block_ name | | | | time | delta | delta | delta --------+------+-----+------+----------+---------+---------+-------- users | 2985 | 1 | 1 | 61919653 | 0 | 49990 | 20 category| 3982 | 1 | 1 | 24136484 | 0 | 11 | 0 sales | 3992 | 2 | 1 | 71736163 | 0 | 1207192 | 32 sales | 4000 | 1 | 1 | 15363010 | -851648 | -851648 | -140 (4 rows) ``` # Vistas de monitoreo de SYS Vistas de monitoreo de SYS Las *vistas de monitoreo* son vistas del sistema en Amazon Redshift que se utilizan para monitorizar el uso de recursos de consulta y carga de trabajo de los clústeres y grupos de trabajo sin servidor. Estas vistas se encuentran en el esquema `pg_catalog`. Para mostrar la información que proporcionan estas vistas, ejecute las instrucciones SELECT de SQL. A menos que se indique lo contrario, estas vistas están disponibles para clústeres de Amazon Redshift y grupos de trabajo de Amazon Redshift sin servidor. *SYS\$1SERVERLESS\$1USAGE* recopila datos de uso de Amazon Redshift sin servidor únicamente. **Topics** + [ # SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY ](r_SYS_ANALYZE_COMPRESSION_HISTORY.md) + [ # SYS\$1ANALYZE\$1HISTORY ](SYS_ANALYZE_HISTORY.md) + [ # SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG ](SYS_APPLIED_MASKING_POLICY_LOG.md) + [ # SYS\$1AUTOMATIC\$1OPTIMIZATION ](SYS_AUTOMATIC_OPTIMIZATION.md) + [ # SYS\$1AUTO\$1TABLE\$1OPTIMIZATION ](r_SYS_AUTO_TABLE_OPTIMIZATION.md) + [ # SYS\$1CHILD\$1QUERY\$1TEXT ](SYS_CHILD_QUERY_TEXT.md) + [ # SYS\$1CONNECTION\$1LOG ](SYS_CONNECTION_LOG.md) + [ # SYS\$1COPY\$1JOB ](SYS_COPY_JOB.md) + [ # SYS\$1COPY\$1JOB\$1DETAIL ](SYS_COPY_JOB_DETAIL.md) + [ # SYS\$1COPY\$1JOB\$1INFO ](SYS_COPY_JOB_INFO.md) + [ # SYS\$1COPY\$1REPLACEMENTS ](SYS_COPY_REPLACEMENTS.md) + [ # SYS\$1DATASHARE\$1CHANGE\$1LOG ](SYS_DATASHARE_CHANGE_LOG.md) + [ # SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE ](r_SYS_DATASHARE_CROSS_REGION_USAGE.md) + [ # SYS\$1DATASHARE\$1USAGE\$1CONSUMER ](SYS_DATASHARE_USAGE_CONSUMER.md) + [ # SYS\$1DATASHARE\$1USAGE\$1PRODUCER ](SYS_DATASHARE_USAGE_PRODUCER.md) + [ # SYS\$1EXTERNAL\$1QUERY\$1DETAIL ](SYS_EXTERNAL_QUERY_DETAIL.md) + [ # SYS\$1EXTERNAL\$1QUERY\$1ERROR ](SYS_EXTERNAL_QUERY_ERROR.md) + [ # SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION ](SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.md) + [ # SYS\$1INTEGRATION\$1ACTIVITY ](r_SYS_INTEGRATION_ACTIVITY.md) + [ # SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY ](r_SYS_INTEGRATION_TABLE_ACTIVITY.md) + [ # SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE ](r_SYS_INTEGRATION_TABLE_STATE_CHANGE.md) + [ # SYS\$1LOAD\$1DETAIL ](SYS_LOAD_DETAIL.md) + [ # SYS\$1LUDF\$1DETAIL ](SYS_LUDF_DETAIL.md) + [ # SYS\$1LOAD\$1ERROR\$1DETAIL ](SYS_LOAD_ERROR_DETAIL.md) + [ # SYS\$1LOAD\$1HISTORY ](SYS_LOAD_HISTORY.md) + [ # SYS\$1MV\$1REFRESH\$1HISTORY ](SYS_MV_REFRESH_HISTORY.md) + [ # SYS\$1MV\$1STATE ](SYS_MV_STATE.md) + [ # SYS\$1PROCEDURE\$1CALL ](SYS_PROCEDURE_CALL.md) + [ # SYS\$1PROCEDURE\$1MESSAGES ](SYS_PROCEDURE_MESSAGES.md) + [ # SYS\$1QUERY\$1DETAIL ](SYS_QUERY_DETAIL.md) + [ # SYS\$1QUERY\$1EXPLAIN ](SYS_QUERY_EXPLAIN.md) + [ # SYS\$1QUERY\$1HISTORY ](SYS_QUERY_HISTORY.md) + [ # SYS\$1QUERY\$1TEXT ](SYS_QUERY_TEXT.md) + [ # SYS\$1REDSHIFT\$1TEMPLATE ](SYS_REDSHIFT_TEMPLATE.md) + [ # SYS\$1RESTORE\$1LOG ](SYS_RESTORE_LOG.md) + [ # SYS\$1RESTORE\$1STATE ](SYS_RESTORE_STATE.md) + [ # SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS ](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md) + [ # SYS\$1SERVERLESS\$1USAGE ](SYS_SERVERLESS_USAGE.md) + [ # SYS\$1SESSION\$1HISTORY ](SYS_SESSION_HISTORY.md) + [ # SYS\$1SPATIAL\$1SIMPLIFY ](SYS_SPATIAL_SIMPLIFY.md) + [ # SYS\$1STREAM\$1SCAN\$1ERRORS ](r_SYS_STREAM_SCAN_ERRORS.md) + [ # SYS\$1STREAM\$1SCAN\$1STATES ](r_SYS_STREAM_SCAN_STATES.md) + [ # SYS\$1TRANSACTION\$1HISTORY ](SYS_TRANSACTION_HISTORY.md) + [ # SYS\$1UDF\$1LOG ](SYS_UDF_LOG.md) + [ # SYS\$1UNLOAD\$1DETAIL ](SYS_UNLOAD_DETAIL.md) + [ # SYS\$1UNLOAD\$1HISTORY ](SYS_UNLOAD_HISTORY.md) + [ # SYS\$1USERLOG ](SYS_USERLOG.md) + [ # SYS\$1VACUUM\$1HISTORY ](SYS_VACUUM_HISTORY.md) # SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY Registra detalles para las operaciones de análisis de compresión durante los comandos COPY o ANALYZE COMPRESSION. SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_ANALYZE_COMPRESSION_HISTORY.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo inspecciona los detalles del análisis de compresión en la tabla `lineitem` por el último comando COPY ejecutado en la misma sesión. ``` select transaction_id, table_id, btrim(table_name) as table_name, column_position, old_encoding, new_encoding, mode from sys_analyze_compression_history where transaction_id = (select transaction_id from sys_query_history where query_id = pg_last_copy_id()) order by column_position; transaction_id | table_id | table_name | column_position | old_encoding | new_encoding | mode -----------------+-------------+------------+-----------------+-----------------+-----------------+------------- 8196 | 248126 | lineitem | 0 | mostly32 | mostly32 | ON 8196 | 248126 | lineitem | 1 | mostly32 | lzo | ON 8196 | 248126 | lineitem | 2 | lzo | delta32k | ON 8196 | 248126 | lineitem | 3 | delta | delta | ON 8196 | 248126 | lineitem | 4 | bytedict | bytedict | ON 8196 | 248126 | lineitem | 5 | mostly32 | mostly32 | ON 8196 | 248126 | lineitem | 6 | delta | delta | ON 8196 | 248126 | lineitem | 7 | delta | delta | ON 8196 | 248126 | lineitem | 8 | lzo | zstd | ON 8196 | 248126 | lineitem | 9 | runlength | zstd | ON 8196 | 248126 | lineitem | 10 | delta | lzo | ON 8196 | 248126 | lineitem | 11 | delta | delta | ON 8196 | 248126 | lineitem | 12 | delta | delta | ON 8196 | 248126 | lineitem | 13 | bytedict | zstd | ON 8196 | 248126 | lineitem | 14 | bytedict | zstd | ON 8196 | 248126 | lineitem | 15 | text255 | zstd | ON (16 rows) ``` # SYS\$1ANALYZE\$1HISTORY SYS\$1ANALYZE\$1HISTORY Registra los detalles de las operaciones [ANALYZE](https://docs.aws.amazon.com/redshift/latest/dg/r_ANALYZE.html). SYS\$1ANALYZE\$1HISTORY solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_ANALYZE_HISTORY.html) ## Consultas de ejemplo ``` user_id | transaction_id | database_name | schema_name | table_name | table_id | is_automatic | Status | start_time | end_time | rows | modified_rows | analyze_threshold_percent | last_analyze_time ---------+----------------+---------------+-------------+---------------------+----------+--------------+--------+----------------------------+----------+-----------------+------+---------------+---------------------------+--------------------- 101 | 8006 | dev | public | test_table_562bf8dc | 110427 | f | Full | 2023-09-21 18:33:08.504646 | 2023-09-21 18:33:24.296498 | 5 | 5 | 0 | 2000-01-01 00:00:00 ``` # SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG Utilice SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG para rastrear la aplicación de políticas de enmascaramiento de datos dinámicos en consultas que hacen referencia a relaciones protegidas por DDM. SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG es visible para los usuarios siguientes: + Superusuarios + Usuarios con el rol `sys:operator` + Usuarios con el permiso ACCESS SYSTEM TABLE Los usuarios normales verán 0 filas. Tenga en cuenta que SYS\$1APPLIED\$1MASKING\$1POLICY\$1LOG no es visible para los usuarios con el rol `sys:secadmin`. Para obtener más información sobre el enmascaramiento de datos dinámico, vaya a [Enmascaramiento de datos dinámico](t_ddm.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_APPLIED_MASKING_POLICY_LOG.html) ## Consultas de ejemplo El siguiente ejemplo muestra que la política de enmascaramiento `mask_credit_card_full` está adjunta a la tabla `credit_db.public.credit_cards`. ``` select policy_name, database_name, relation_name, schema_name, relation_kind from sys_applied_masking_policy_log; policy_name | database_name | relation_name | schema_name | relation_kind ----------------------+---------------+---------------+-------------+--------------- mask_credit_card_full | credit_db | credit_cards | public | table (1 row) ``` # SYS\$1AUTOMATIC\$1OPTIMIZATION SYS\$1AUTOMATIC\$1OPTIMIZATION Utilice SYS\$1AUTOMATIC\$1OPTIMIZATION para ver los detalles de las tareas que Amazon Redshift ejecuta para la optimización automática, también conocida como características automatizadas. Para obtener más información sobre la automatización automática, consulte [Optimización automática de bases de datos](c_autonomics.md). SYS\$1AUTOMATIC\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_AUTOMATIC_OPTIMIZATION.html) ## Notas de uso Notas de uso La columna compute\$1type estará vacía en el caso de los clústeres sin servidor, ya que no diferenciamos los recursos de computación primarios de los de escala primaria. Los recursos de computación del clúster sin servidor se miden por el uso de unidades de procesamiento de Redshift (RPU). Para obtener más información, consulte [Capacidad informática para Amazon Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-capacity.html). ## Ejemplos Ejemplos La siguiente consulta muestra las optimizaciones automáticas realizadas en la tabla 155259. ``` SELECT pid, trim(task_type) as task_type, trim(database) as database, trim(status) as status, trim(event) as event, event_time from SYS_AUTOMATIC_OPTIMIZATION WHERE object_ids like '%155259%' AND status = 'Task completed successfully'; task_type | database | status | event | event_time ------------+----------------+-----------------------------+-----------+---------------------------- VacuumSort | tpcds_100g_oob | Task completed successfully | Completed | 2025-12-22 07:27:15.943018 ``` La siguiente consulta muestra todas las optimizaciones automáticas de “VacuumSort” ejecutadas. Para obtener más información sobre “VacuumSort”, consulte [Clasificación automática de tablas](t_Reclaiming_storage_space202.md#automatic-table-sort). ``` SELECT trim(task_type) as task_type, trim(database) as database, trim(object_type) as object_type, trim(object_ids) as object_ids, trim(status) as status, trim(event) as event, event_time from SYS_AUTOMATIC_OPTIMIZATION WHERE task_type like '%VacuumSort%' AND status = 'Task completed successfully'; task_type | database | object_type | object_ids | status | event | event_time ------------+----------------+-------------+------------+-----------------------------+-----------+---------------------------- VacuumSort | tpcds_100g_oob | table | 155301 | Task completed successfully | Completed | 2025-12-22 07:14:00.065391 VacuumSort | tpcds_100g_oob | table | 155303 | Task completed successfully | Completed | 2025-12-22 07:14:09.158251 VacuumSort | tpcds_100g_oob | table | 155291 | Task completed successfully | Completed | 2025-12-22 07:17:06.61164 VacuumSort | tpcds_100g_oob | table | 155293 | Task completed successfully | Completed | 2025-12-22 07:17:37.015069 VacuumSort | tpcds_100g_oob | table | 155281 | Task completed successfully | Completed | 2025-12-22 07:18:54.903935 VacuumSort | tpcds_100g_oob | table | 155279 | Task completed successfully | Completed | 2025-12-22 07:20:13.960002 VacuumSort | tpcds_100g_oob | table | 155271 | Task completed successfully | Completed | 2025-12-22 07:21:26.095549 VacuumSort | tpcds_100g_oob | table | 155267 | Task completed successfully | Completed | 2025-12-22 07:22:48.119249 VacuumSort | tpcds_100g_oob | table | 155269 | Task completed successfully | Completed | 2025-12-22 07:24:12.010424 VacuumSort | tpcds_100g_oob | table | 155263 | Task completed successfully | Completed | 2025-12-22 07:25:35.958388 VacuumSort | tpcds_100g_oob | table | 155265 | Task completed successfully | Completed | 2025-12-22 07:26:40.580395 VacuumSort | tpcds_100g_oob | table | 155259 | Task completed successfully | Completed | 2025-12-22 07:27:15.943018 (12 rows) ``` # SYS\$1AUTO\$1TABLE\$1OPTIMIZATION SYS\$1AUTO\$1TABLE\$1OPTIMIZATION Registra las acciones automatizadas realizadas por Amazon Redshift en tablas definidas para la optimización automática. SYS\$1AUTO\$1TABLE\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_AUTO_TABLE_OPTIMIZATION.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, las filas del resultado muestran las acciones realizadas por Amazon Redshift. ``` SELECT table_id, alter_table_type, status, event_time, alter_from FROM SYS_AUTO_TABLE_OPTIMIZATION; table_id | alter_table_type | status | event_time | alter_from ----------+---------------------+------------------------------------------------------+-----------------------------+----------------- 118082 | sortkey | Start | 2020-08-22 19:42:20.727049 | 118078 | sortkey | Start | 2020-08-22 19:43:54.728819 | 118082 | sortkey | Start | 2020-08-22 19:42:52.690264 | 118072 | sortkey | Start | 2020-08-22 19:44:14.793572 | 118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 | 118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | SORTKEY: None; 118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | SORTKEY: None; 118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | SORTKEY: None; 118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 | 118086 | sortkey | Start | 2020-08-22 19:42:00.685255 | 118082 | sortkey | Start | 2020-08-22 19:43:34.69531 | 118072 | sortkey | Start | 2020-08-22 19:44:46.703331 | 118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 | 118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 | 116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 | 110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 | ``` # SYS\$1CHILD\$1QUERY\$1TEXT SYS\$1CHILD\$1QUERY\$1TEXT Devuelve el texto de SQL de una consulta secundaria. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_CHILD_QUERY_TEXT.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, las filas del resultado muestran las acciones realizadas por Amazon Redshift. ``` SELECT * from sys_child_query_text where query_id = '34487366' order by child_query_sequence asc, sequence asc; user_id | query_id | child_query_sequence | sequence | text --------|----------|----------------------|----------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 100 | 34899339 | 1 | 0 | /* RQEV2-aY6ZZ1ZpQK */\nwith venue as (\n select venueid,\n venuename,\n venuestate\n from venue\n), event as (\n select eventid,\n venueid,\n date 100 | 34899339 | 1 | 1 | id,\n eventname\n from event\n where eventname like '3 Doors Down'\n), users as (\n select userid\n from users\n), sales as (\n select salesid,\n pricepaid, 100 | 34899339 | 1 | 2 | \n eventid,\n buyerid\n from sales\n)\nselect e.eventname,\n v.venuename,\n count(distinct(u.userid)) as unique_customers,\n sum(s.pricepaid) as total_sal 100 | 34899339 | 1 | 3 | es\nfrom venue as v inner join event e on v.venueid = e.venueid\ninner join sales s on e.eventid = s.eventid inner join users u on s.buyerid = u.userid\ngroup by 1,2\norder by 4 desc limit 100 ``` # SYS\$1CONNECTION\$1LOG SYS\$1CONNECTION\$1LOG Registra los intentos de autenticación y las conexiones y desconexiones. SYS\$1CONNECTION\$1LOG solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_CONNECTION_LOG.html) ## Consultas de ejemplo Consultas de ejemplo Para ver los detalles de las conexiones abiertas, ejecute la siguiente consulta. ``` select record_time, user_name, database_name, remote_host, remote_port from sys_connection_log where event = 'initiating session' and session_id not in (select session_id from sys_connection_log where event = 'disconnecting session') order by 1 desc; record_time | user_name | database_name | remote_host | remote_port --------------------+-------------+-----------------+---------------+--------------------------------- 2014-11-06 20:30:06 | rdsdb | dev | [local] | 2014-11-06 20:29:37 | test001 | test | 10.49.42.138 | 11111 2014-11-05 20:30:29 | rdsdb | dev | 10.49.42.138 | 33333 2014-11-05 20:28:35 | rdsdb | dev | [local] | (4 rows) ``` En el siguiente ejemplo, se refleja un intento fallido de autenticación y una correcta conexión y desconexión. ``` select event, record_time, remote_host, user_name from sys_connection_log order by record_time; event | record_time | remote_host | user_name -----------------------+----------------------------+---------------+--------- authentication failure | 2012-10-25 14:41:56.96391 | 10.49.42.138 | john authenticated | 2012-10-25 14:42:10.87613 | 10.49.42.138 | john initiating session | 2012-10-25 14:42:10.87638 | 10.49.42.138 | john disconnecting session | 2012-10-25 14:42:19.95992 | 10.49.42.138 | john (4 rows) ``` En el siguiente ejemplo, se muestra la versión del controlador ODBC, el sistema operativo del equipo cliente y el complemento utilizado para conectarse al clúster de Amazon Redshift. En este ejemplo, el complemento se utiliza para la autenticación de controladores ODBC estándar mediante un nombre de inicio de sesión y una contraseña. ``` select driver_version, os_version, plugin_name from sys_connection_log; driver_version | os_version | plugin_name ----------------------------------------+-----------------------------------+-------------------- Amazon Redshift ODBC Driver 1.4.15.0001 | Darwin 18.7.0 x86_64 | none Amazon Redshift ODBC Driver 1.4.15.0001 | Linux 4.15.0-101-generic x86_64 | none ``` En el siguiente ejemplo, se muestra la versión del sistema operativo en el equipo cliente, la versión del controlador y la versión del protocolo. ``` select os_version, driver_version, protocol_version from sys_connection_log; os_version | driver_version | protocol_version --------------------------------+------------------------------+-------------------- Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 Linux 4.15.0-101-generic x86_64 | Redshift JDBC Driver 2.0.0.0 | 2 ``` # SYS\$1COPY\$1JOB SYS\$1COPY\$1JOB Utilice SYS\$1COPY\$1JOB para ver los detalles de los comandos COPY JOB. Esta vista contiene los comandos COPY JOB que se han creado. SYS\$1COPY\$1JOB es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB.html) # SYS\$1COPY\$1JOB\$1DETAIL SYS\$1COPY\$1JOB\$1DETAIL Utilice SYS\$1COPY\$1JOB\$1DETAIL para ver los detalles de los comandos COPY JOB. Esta vista contiene los comandos COPY JOB que se han creado. Si COPY JOB intenta cargar un archivo y este no se carga, el archivo se omitirá en futuros intentos automáticos de COPY JOB. SYS\$1COPY\$1JOB\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB_DETAIL.html) El ejemplo siguiente devuelve una fila donde se muestran las entradas ingeridas. ``` SELECT * FROM SYS_COPY_JOB_DETAIL WHERE status ilike '%ingested%' limit 1; user_id | 100 database_name | dev job_name | many_job_4_3 job_id | 110702 file_location | saral-sqs-system4623202051-0 file_name | frenzy-9/4623202051/file_0_107 file_size | 11302 file_etag | 51b2d78ac5b5aecf4ee6f8374815ad19 modification_time | 2024-07-15 20:43:14 enqueue_time | 2024-07-15 20:44:24 status | Ingested ``` # SYS\$1COPY\$1JOB\$1INFO SYS\$1COPY\$1JOB\$1INFO Utilice SYS\$1COPY\$1JOB\$1INFO para visualizar los mensajes registrados sobre un COPY JOB. Esta vista contiene información sobre los errores de un COPY JOB que se ha ejecutado. SYS\$1COPY\$1JOB\$1INFO es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_JOB_INFO.html) # SYS\$1COPY\$1REPLACEMENTS SYS\$1COPY\$1REPLACEMENTS Muestra un registro de los momentos en que se reemplazaron caracteres UTF-8 no válidos por el comando [COPY](r_COPY.md) con la opción ACCEPTINVCHARS. Se agrega una entrada de registro a SYS\$1COPY\$1REPLACEMENTS por cada una de las 100 primeras filas de cada sector del nodo que necesitaron al menos un reemplazo. Puede utilizar esta vista para consultar información sobre los grupos de trabajo sin servidor y los clústeres aprovisionados. SYS\$1COPY\$1REPLACEMENTS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_COPY_REPLACEMENTS.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo devuelve los reemplazos de la operación COPY más reciente. ``` select query_idp, table_id, file_name, line_number, colname from sys_copy_replacements where query = pg_last_copy_id(); query_id | table_id | file_name | line_number | column_name ---------+----------+-------------------------------------------------------+-------------+-------- 96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 123 | city 96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 456 | city 96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 789 | city 96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 012 | city 96 | 26 | s3://DOC-EXAMPLE-BUCKET/allusers_pipe.txt | 119 | city ... ``` # SYS\$1DATASHARE\$1CHANGE\$1LOG SYS\$1DATASHARE\$1CHANGE\$1LOG Registra la vista consolidada para realizar el seguimiento de los cambios en los datashares (recursos para compartir datos) tanto en los clústeres productores como en los consumidores. SYS\$1DATASHARE\$1CHANGE\$1LOG es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_CHANGE_LOG.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SYS\$1DATASHARE\$1CHANGE\$1LOG. ``` SELECT DISTINCT action FROM sys_datashare_change_log WHERE share_object_name LIKE 'tickit%'; action ----------------------- "ALTER DATASHARE ADD" ``` # SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE Utilice la vista SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE para obtener un resumen del uso de datos transferidos entre regiones debido a la consulta de uso compartido de datos entre regiones. SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE agrega detalles en el nivel de segmento. Solo los superusuarios pueden ver SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_DATASHARE_CROSS_REGION_USAGE.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE. ``` SELECT query_id, segment_id, transferred_data, source_region from sys_datashare_cross_region_usage where query_id = pg_last_query_id() order by query_id, segment_id; query_id | segment_id | transferred_data | source_region -----------+------------+------------------+--------------- 200048 | 2 | 4194304 | us-west-1 200048 | 2 | 4194304 | us-east-2 ``` # SYS\$1DATASHARE\$1USAGE\$1CONSUMER SYS\$1DATASHARE\$1USAGE\$1CONSUMER Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster consumidor. SYS\$1DATASHARE\$1USAGE\$1CONSUMER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_USAGE_CONSUMER.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra la vista SYS\$1DATASHARE\$1USAGE\$1CONSUMER. ``` SELECT request_type, status, trim(error) AS error FROM sys_datashare_usage_consumer request_type | status | error_message ----------------+--------+--------------- "GET RELATION" | 0 | ``` # SYS\$1DATASHARE\$1USAGE\$1PRODUCER SYS\$1DATASHARE\$1USAGE\$1PRODUCER Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster productor. SVL\$1DATASHARE\$1USAGE\$1PRODUCER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_DATASHARE_USAGE_PRODUCER.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra la vista SYS\$1DATASHARE\$1USAGE\$1PRODUCER. ``` SELECT DISTINCT FROM sys_datashare_usage_producer WHERE object_name LIKE 'tickit%'; request_type ------------------ "GET RELATION" ``` # SYS\$1EXTERNAL\$1QUERY\$1DETAIL SYS\$1EXTERNAL\$1QUERY\$1DETAIL Utilice SYS\$1EXTERNAL\$1QUERY\$1DETAIL para visualizar los detalles de las consultas en el nivel del segmento. Cada fila representa un segmento de una determinada consulta de WLM con una serie de detalles como el número de filas procesadas, el número de bytes procesados y la información de partición de las tablas externas en Amazon S3. Cada fila de esta vista tendrá también una entrada correspondiente en la vista SYS\$1QUERY\$1DETAIL, con la diferencia de que esta última contiene más información detallada relativa al procesamiento de las consultas externas. SYS\$1EXTERNAL\$1QUERY\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTERNAL_QUERY_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra los detalles de la consulta externa. ``` SELECT query_id, segment_id, start_time, end_time, total_partitions, qualified_partitions, scanned_files, returned_rows, returned_bytes, trim(external_query_text) query_text, trim(file_location) file_location FROM sys_external_query_detail ORDER BY query_id, start_time DESC LIMIT 2; ``` Resultados de ejemplo. ``` query_id | segment_id | start_time | end_time | total_partitions | qualified_partitions | scanned_files | returned_rows | returned_bytes | query_text | file_location ----------+------------+----------------------------+----------------------------+------------------+----------------------+---------------+---------------+----------------+------------+--------------- 763251 | 0 | 2022-02-15 22:32:23.312448 | 2022-02-15 22:32:24.036023 | 3 | 3 | 3 | 38203 | 2683414 | | 763254 | 0 | 2022-02-15 22:32:40.17103 | 2022-02-15 22:32:40.839313 | 3 | 3 | 3 | 38203 | 2683414 | | ``` # SYS\$1EXTERNAL\$1QUERY\$1ERROR SYS\$1EXTERNAL\$1QUERY\$1ERROR Puede consultar la vista del sistema SYS\$1EXTERNAL\$1QUERY\$1ERROR para obtener información acerca de los errores de análisis de Redshift Spectrum. SYS\$1EXTERNAL\$1QUERY\$1ERROR muestra un ejemplo de los errores registrados. El valor predeterminado es 10 entradas por consulta. SYS\$1EXTERNAL\$1QUERY\$1ERROR es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTERNAL_QUERY_ERROR.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve la lista de filas para las que se han realizado operaciones de control de datos. ``` SELECT * FROM sys_external_query_error; ``` La consulta devuelve resultados similares a los siguientes. ``` user_id query_id file_location rowid column_name original_value modified_value trigger action action_value error_code 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156 ``` # SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION Utilice SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION para ver los períodos de uso en los que Amazon Redshift ejecutó tareas de optimización automática con recursos de computación adicional. Para obtener más información sobre la automatización automática, consulte [Optimización automática de bases de datos](c_autonomics.md). Para obtener más información sobre las optimizaciones automáticas que se ejecutan con recursos de computación adicional, consulte [Asignación de recursos de computación adicional para la optimización automática de bases de datos](t_extra-compute-autonomics.md). SYS\$1EXTRA\$1COMPUTE\$1FOR\$1AUTOMATIC\$1OPTIMIZATION solo está disponible para los clústeres aprovisionados. SYS\$1AUTO\$1TABLE\$1OPTIMIZATION solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_EXTRA_COMPUTE_FOR_AUTOMATIC_OPTIMIZATION.html) ## Ejemplos Ejemplos A continuación se muestra un ejemplo de consulta en la que se buscan optimizaciones automáticas realizadas el 16 de septiembre de 2025. ``` SELECT * FROM sys_extra_compute_for_automatic_optimization WHERE start_time BETWEEN '2025-09-16 00:00:00' AND '2025-09-16 23:59:59'; start_time | end_time | query_count | compute_seconds ---------------------+---------------------+-------------+----------------- 2025-09-16 00:00:00 | 2025-09-16 00:00:59 | 1 | 59 2025-09-16 00:01:05 | 2025-09-16 00:01:58 | 2 | 53 ``` # SYS\$1INTEGRATION\$1ACTIVITY SYS\$1INTEGRATION\$1ACTIVITY SYS\$1INTEGRATION\$1ACTIVITY muestra detalles sobre las ejecuciones de integración completadas. SYS\$1INTEGRATION\$1ACTIVITY solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Para obtener información sobre las integraciones sin ETL, consulte [Uso de integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html) en la guía de administración de Amazon Redshift. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_ACTIVITY.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando SQL muestra el registro de las integraciones. ``` select * from sys_integration_activity; integration_id | target_database | source | checkpoint_name | checkpoint_type | checkpoint_bytes | last_commit_timestamp | modified_tables | integration_start_time | integration_end_time --------------------------------------+-----------------+--------+---------------------------------------------+------------------+------------------+-------------------------+-----------------+----------------------------+---------------------------- 76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_241_3_510.json | cdc | 762 | 2023-05-10 23:00:14.201 | 1 | 2023-05-10 23:00:45.054265 | 2023-05-10 23:00:46.339826 76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_16329_3_17839.json | cdc | 13488 | 2023-05-11 01:33:57.411 | 2 | 2023-05-11 02:19:09.440121 | 2023-05-11 02:19:16.090492 76b15917-afae-4447-b7fd-08e2a5acce7b | demo1 | MySQL | checkpoints/checkpoint_3_5103_3_5532.json | cdc | 1657 | 2023-05-10 23:13:14.205 | 2 | 2023-05-10 23:13:23.545487 | 2023-05-10 23:13:25.652144 ``` # SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY SYS\$1INTEGRATION\$1TABLE\$1ACTIVITY muestra los detalles de la actividad de inserción, eliminación y actualización de las integraciones sin ETL. Se añade una fila por cada ingesta completada. Un superusuario puede ver todas las filas de esta tabla. Para obtener más información, consulte [Integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_ACTIVITY.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando de SQL muestra la actividad de la integración. ``` select * from sys_integration_table_activity; integration_id | checkpoint_name | target_database | schema_name | table_name | table_id | record_time | transaction_id | inserted_rows | deleted_rows | updated_rows | bytes_ingested --------------------------------------+-----------------+-----------------+-------------+-------------------+--------------+----------------------------+-----------------+----------------+--------------+--------------+--------------- 4798e675-8f9f-4686-b05f-92c538e19629 | | sample_test2 | sample | SampleTestChannel | 111276 | 2023-05-12 12:40:30.656625 | 7736 | 2 | 0 | 0 | 125 ``` # SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE SYS\$1INTEGRATION\$1TABLE\$1STATE\$1CHANGE: muestra los detalles de los registros de cambios de estados de tabla para las integraciones. Un superusuario puede ver todas las filas de esta tabla. Para obtener más información, consulte [Uso de integraciones sin ETL](https://docs.aws.amazon.com//redshift/latest/mgmt/zero-etl-using.html). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_INTEGRATION_TABLE_STATE_CHANGE.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente comando SQL muestra el registro de las integraciones. ``` select * from sys_integration_table_state_change; integration_id | database_name | schema_name | table_name | new_state | table_last_replicated_checkpoint | state_change_reason | record_time --------------------------------------+---------------+-------------+------------+-----------+-------------------------------------+---------------------+---------------------------- 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest79 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:50.087868 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest56 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:39:45.54005 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest50 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:20.362504 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest80t3s | sbtest18 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 19:40:32.544084 99108e72-1cfd-414f-8cc0-0216acefac77 | perfdb | sbtest40t3s | sbtest23 | Synced | {"txn_seq":9834,"txn_id":126597515} | | 2023-09-20 15:49:05.186209 ``` # SYS\$1LOAD\$1DETAIL SYS\$1LOAD\$1DETAIL Devuelve información para realizar un seguimiento o solucionar problemas en la carga de datos. En esta vista, se registra el progreso de cada archivo de datos mientras se carga en una tabla de base de datos. Todos los usuarios pueden acceder a esta vista. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo devuelve los detalles de la última operación COPY. ``` select query_id, trim(file_name) as file, record_time from sys_load_detail where query_id = pg_last_copy_id(); query_id | file | record_time ----------+----------------------------------+---------------------------- 28554 | s3://dw-tickit/category_pipe.txt | 2013-11-01 17:14:52.648486 (1 row) ``` La siguiente consulta tiene entradas para una carga nueva de las tablas en la base de datos TICKIT: ``` select query_id, trim(file_name), record_time from sys_load_detail where file_name like '%tickit%' order by query_id; query_id | btrim | record_time ----------+--------------------------+---------------------------- 22475 | tickit/allusers_pipe.txt | 2013-02-08 20:58:23.274186 22478 | tickit/venue_pipe.txt | 2013-02-08 20:58:25.070604 22480 | tickit/category_pipe.txt | 2013-02-08 20:58:27.333472 22482 | tickit/date2008_pipe.txt | 2013-02-08 20:58:28.608305 22485 | tickit/allevents_pipe.txt| 2013-02-08 20:58:29.99489 22487 | tickit/listings_pipe.txt | 2013-02-08 20:58:37.632939 22593 | tickit/allusers_pipe.txt | 2013-02-08 21:04:08.400491 22596 | tickit/venue_pipe.txt | 2013-02-08 21:04:10.056055 22598 | tickit/category_pipe.txt | 2013-02-08 21:04:11.465049 22600 | tickit/date2008_pipe.txt | 2013-02-08 21:04:12.461502 22603 | tickit/allevents_pipe.txt| 2013-02-08 21:04:14.785124 22605 | tickit/listings_pipe.txt | 2013-02-08 21:04:20.170594 (12 rows) ``` El hecho de que se escriba un registro en el archivo de registros para esta vista de sistema no implica que la carga se haya confirmado correctamente como parte de la transacción que contiene. Para comprobar las confirmaciones de carga, consulte la vista STL\$1UTILITYTEXT y busque el registro COMMIT que corresponda a esa transacción COPY. Por ejemplo, esta consulta combina SYS\$1LOAD\$1DETAIL y STL\$1QUERY en función de una subconsulta de STL\$1UTILITYTEXT: ``` select l.query_id,rtrim(l.file_name),q.transaction_id from sys_load_detail l, sys_query_text q where l.query_id=q.query_id and exists (select xid from stl_utilitytext where xid=q.transaction_id and rtrim("text")='COMMIT'); query_id | rtrim | transaction_id ----------+---------------------------+----------------- 22600 | tickit/date2008_pipe.txt | 68311 22480 | tickit/category_pipe.txt | 68066 7508 | allusers_pipe.txt | 23365 7552 | category_pipe.txt | 23415 7576 | allevents_pipe.txt | 23429 7516 | venue_pipe.txt | 23390 7604 | listings_pipe.txt | 23445 22596 | tickit/venue_pipe.txt | 68309 22605 | tickit/listings_pipe.txt | 68316 22593 | tickit/allusers_pipe.txt | 68305 22485 | tickit/allevents_pipe.txt | 68071 7561 | allevents_pipe.txt | 23429 7541 | category_pipe.txt | 23415 7558 | date2008_pipe.txt | 23428 22478 | tickit/venue_pipe.txt | 68065 526 | date2008_pipe.txt | 2572 7466 | allusers_pipe.txt | 23365 22482 | tickit/date2008_pipe.txt | 68067 22598 | tickit/category_pipe.txt | 68310 22603 | tickit/allevents_pipe.txt | 68315 22475 | tickit/allusers_pipe.txt | 68061 547 | date2008_pipe.txt | 2572 22487 | tickit/listings_pipe.txt | 68072 7531 | venue_pipe.txt | 23390 7583 | listings_pipe.txt | 23445 (25 rows) ``` # SYS\$1LUDF\$1DETAIL SYS\$1LUDF\$1DETAIL SYS\$1LUDF\$1DETAIL registra la información y las métricas de las funciones definidas por el usuario de Lambda (LUDF) que se utilizaron en una consulta concreta. SYS\$1LUDF\$1DETAIL solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LUDF_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo se utiliza una UDF de Lambda en una consulta y, a continuación, se muestra cómo consultar la vista SYS\$1LUDF\$1DETAIL para ver los detalles de ejecución de la función. ``` SET SESSION AUTHORIZATION regular_user; CREATE EXTERNAL FUNCTION exfunc_sum(INT,INT) RETURNS INT STABLE LAMBDA 'lambda_sum' IAM_ROLE 'arn:aws:iam::123456789012:role/Redshift-Exfunc-Test'; CREATE TABLE t_sum(c1 int, c2 int); INSERT INTO t_sum VALUES (4,5), (6,7); SELECT exfunc_sum(c1,c2) FROM t_sum; -- Switch to super user in order to inspect records in the LUDF SYS view. SET SESSION AUTHORIZATION super_user; select * from sys_ludf_detail; ``` Código de salida de ejemplo: ``` user_id | transaction_id | query_id | function_oid | function_position | stream_id | segment_id | step_id | lambda_function_name | start_time | end_time | total_duration | invocations | total_rows | input_bytes | output_bytes ---------+----------------+----------+--------------+-------------------+-----------+------------+---------+----------------------+----------------------------+----------------------------+----------------+-------------+------------+-------------+-------------- 100 | 1463 | 1544 | 111055 | 0 | 0 | 0 | 2 | lambda_sum | 2026-01-06 17:23:25.165898 | 2026-01-06 17:23:25.165898 | 414 | 1 | 2 | 277 | 18 (1 row) ``` # SYS\$1LOAD\$1ERROR\$1DETAIL SYS\$1LOAD\$1ERROR\$1DETAIL Utilice SYS\$1LOAD\$1ERROR\$1DETAIL para visualizar los detalles de los errores del comando COPY. Cada una de las filas representa un comando COPY. Contiene tanto los comandos COPY en ejecución como los que han finalizado. SYS\$1LOAD\$1ERROR\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_ERROR_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra los detalles del error de carga del comando copy de una consulta específica. ``` SELECT query_id, table_id, start_time, trim(file_name) AS file_name, trim(column_name) AS column_name, trim(column_type) AS column_type, trim(error_message) AS error_message FROM sys_load_error_detail WHERE query_id = 762949 ORDER BY start_time LIMIT 10; ``` Resultados de ejemplo. ``` query_id | table_id | start_time | file_name | column_name | column_type | error_message ----------+----------+----------------------------+------------------------------------------+-------------+-------------+------------------------------------------------ 762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_000 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer 762949 | 137885 | 2022-02-15 22:14:46.759151 | s3://load-test/copyfail/wrong_format_001 | id | int4 | Invalid digit, Value 'a', Pos 0, Type: Integer ``` # SYS\$1LOAD\$1HISTORY SYS\$1LOAD\$1HISTORY Utilice SYS\$1LOAD\$1HISTORY para visualizar los detalles de los comandos COPY. Cada una de las filas representa un comando COPY con estadísticas acumuladas para algunos de los campos. Contiene tanto los comandos COPY en ejecución como los que han finalizado. SYS\$1LOAD\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_LOAD_HISTORY.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra las filas, los bytes, las tablas y el origen de datos cargados de comandos de copia específicos. ``` SELECT query_id, table_name, data_source, loaded_rows, loaded_bytes FROM sys_load_history WHERE query_id IN (6389,490791,441663,74374,72297) ORDER BY query_id, data_source DESC; ``` Resultados de ejemplo. ``` query_id | table_name | data_source | loaded_rows | loaded_bytes ----------+------------------+-----------------------------------------------------------------------+-------------+--------------- 6389 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196240296158 72297 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808 74374 | ship_mode | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/ship_mode/ | 20 | 1320 441663 | income_band | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/income_band/ | 20 | 2152 490791 | customer_address | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/customer_address/ | 6000000 | 722924305 ``` La siguiente consulta muestra las filas, los bytes, las tablas y el origen de datos cargados de comandos copy. ``` SELECT query_id, table_name, data_source, loaded_rows, loaded_bytes FROM sys_load_history ORDER BY query_id DESC LIMIT 10; ``` Resultados de ejemplo. ``` query_id | table_name | data_source | loaded_rows | loaded_bytes ----------+------------------------+-----------------------------------------------------------------------------+-------------+----------------- 491058 | web_site | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_site/ | 54 | 43808 490947 | web_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_sales/ | 720000376 | 22971988122819 490923 | web_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_returns/ | 71997522 | 96597496325 490918 | web_page | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/web_page/ | 3000 | 1320 490907 | warehouse | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/warehouse/ | 20 | 1320 490902 | time_dim | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/time_dim/ | 86400 | 1320 490876 | store_sales | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_sales/ | 2879987999 | 151666241887933 490870 | store_returns | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store_returns/ | 287999764 | 1196405607941 490865 | store | s3://load-test/data-sources/tpcds/2.8.0/textfile/1T/store/ | 1002 | 365507 ``` La siguiente consulta muestra las filas y los bytes cargados del comando copy. ``` SELECT date_trunc('day',start_time) AS exec_day, SUM(loaded_rows) AS loaded_rows, SUM(loaded_bytes) AS loaded_bytes FROM sys_load_history GROUP BY exec_day ORDER BY exec_day DESC; ``` Resultados de ejemplo. ``` exec_day | loaded_rows | loaded_bytes ---------------------+-------------+------------------ 2022-01-20 00:00:00 | 6347386005 | 258329473070606 2022-01-19 00:00:00 | 19042158015 | 775198502204572 2022-01-18 00:00:00 | 38084316030 | 1550294469446883 2022-01-17 00:00:00 | 25389544020 | 1033271084791724 2022-01-16 00:00:00 | 19042158015 | 775222736252792 2022-01-15 00:00:00 | 19834245387 | 798122849155598 2022-01-14 00:00:00 | 75376544688 | 3077040926571384 ``` # SYS\$1MV\$1REFRESH\$1HISTORY SYS\$1MV\$1REFRESH\$1HISTORY Los resultados incluyen información sobre el historial de actualizaciones de todas las vistas materializadas. Los resultados incluyen el tipo de actualización, como manual o automática, y el estado de la actualización más reciente. SYS\$1MV\$1REFRESH\$1HISTORY está visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_MV_REFRESH_HISTORY.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra el historial de actualizaciones de las vistas materializadas. ``` SELECT user_id, session_id, transaction_id, database_name, schema_name, mv_id, mv_name, refresh_type, status, start_time, end_time, duration, consumer_account, consumer_region, consumer_namespace from sys_mv_refresh_history; ``` La consulta devuelve el siguiente ejemplo de salida: ``` user_id | session_id | transaction_id | database_name | schema_name | mv_id | mv_name | refresh_type | status | start_time | end_time | duration | consumer_account | consumer_region | consumer_namespace ---------+------------+----------------+---------------+----------------------------+--------+--------------------+----------------+------------------------------------------------------------------------------------------------------+----------------------------+----------------------------+-----------+------------------+-----------------+------------------------------------ 1 | 1073815659 | 15066 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | MV was already updated | 2023-10-26 15:59:20.952179 | 2023-10-26 15:59:20.952866 | 687 | | | 1 | 1073815659 | 15068 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | MV was already updated | 2023-10-26 15:59:21.008049 | 2023-10-26 15:59:21.008658 | 609 | | | 1 | 1073815659 | 15070 | ext_db | producer_schema | 203779 | producer_mv | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:21.064252 | 2023-10-26 15:59:21.064885 | 633 | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af 1 | 1073815659 | 15074 | dev | test_stl_mv_refresh_schema | 203762 | mv_incremental | Manual | Refresh successfully updated MV incrementally | 2023-10-26 15:59:29.693329 | 2023-10-26 15:59:43.482842 | 13789513 | | | 1 | 1073815659 | 15076 | dev | test_stl_mv_refresh_schema | 203771 | mv_nonincremental | Manual | Refresh successfully recomputed MV from scratch | 2023-10-26 15:59:43.550184 | 2023-10-26 15:59:47.880833 | 4330649 | | | 1 | 1073815659 | 15078 | dev | test_stl_mv_refresh_schema | 203779 | mv_refresh_error | Manual | Refresh failed due to an internal error | 2023-10-26 15:59:47.949052 | 2023-10-26 15:59:52.494681 | 4545629 | | | 1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh failed because materialized view test_stl_mv_refresh_schema.child was not refreshed. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | | 1 | 1073815659 | 15071 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:30:21.432252 | 2023-10-26 15:30:21.432252 | 532 | | | 1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203778 | mv_test | Manual | Cascade refresh skipped because materialized view test_stl_mv_refresh_schema.child was not refreshed.| 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633 1 | 1073815659 | 15069 | dev | test_stl_mv_refresh_schema | 203761 | child | Manual | Refresh failed due to an internal error. | 2023-10-26 15:21:43.550369 | 2023-10-26 15:21:43.550369 | 633 (10 rows) ``` # SYS\$1MV\$1STATE SYS\$1MV\$1STATE Los resultados incluyen información sobre el estado de todas las vistas materializadas. Incluye información de la tabla base, propiedades del esquema e información sobre eventos recientes, como la eliminación de una columna. SYS\$1MV\$1STATE es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_MV_STATE.html) ## Consultas de ejemplo Consultas de ejemplo En la siguiente consulta se muestra el estado de la vista materializada. ``` select * from sys_mv_state; ``` La consulta devuelve el siguiente ejemplo de salida: ``` user_id | transaction_id | database_name | event_desc | start_time | base_table_database_name | base_table_schema | base_table_name | mv_schema | mv_name | state ---------+----------------+---------------+-----------------------------+----------------------------+--------------------------+-------------------+---------------------+-------------+----------------------------+-------------- 106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788268 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Recompute 106 | 12724 | tickit_db | ALTER TABLE ALTER DISTSTYLE | 2023-07-26 14:59:51.409014 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute 106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.822928 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable 106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051244 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable 106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857755 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Unrefreshable 106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051358 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Unrefreshable 106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788159 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5750a8d4 | Recompute 106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.857799 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable 106 | 12720 | tickit_db | TRUNCATE | 2023-07-26 14:59:12.788327 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_5ef0d754 | Recompute 106 | 12727 | tickit_db | ALTER TABLE ALTER SORTKEY | 2023-07-26 15:00:08.006235 | tickit_db | mv_schema | test_table_58102435 | mv_schema | materialized_view_ca746631 | Recompute 106 | 12720 | tickit_db | Column was renamed | 2023-07-26 14:59:12.82297 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable 106 | 12727 | tickit_db | Table was renamed | 2023-07-26 15:00:08.051321 | tickit_db | mv_schema | test_table_95d6d861 | mv_schema | materialized_view_a1f3f862 | Unrefreshable ``` # SYS\$1PROCEDURE\$1CALL SYS\$1PROCEDURE\$1CALL Utilice la vista SYS\$1PROCEDURE\$1CALL para obtener información sobre las llamadas a procedimientos almacenados, incluida la hora de inicio, la hora de finalización, el estado de una llamada a un procedimiento almacenado y la jerarquía de llamadas para las llamadas a procedimientos almacenados anidados. Cada llamada de procedimiento almacenado recibe un ID de consulta. SYS\$1STORED\$1PROC\$1CALL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_PROCEDURE_CALL.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve una jerarquía de llamadas a procedimientos almacenados anidados. ``` select query_id, datediff(seconds, start_time, end_time) as elapsed_time, status, trim(query_text) as call, caller_procedure_query_id from sys_procedure_call; ``` Resultados de ejemplo. ``` query_id | elapsed_time | status | call | caller_procedure_query_id ----------+--------------+---------+--------------------------------------------------+--------------------------- 3087 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d(1) | 3085 3085 | 18 | success | CALL proc_bd906c98c45443ffa165e9552056902d_2(1); | (2 rows) ``` # SYS\$1PROCEDURE\$1MESSAGES SYS\$1PROCEDURE\$1MESSAGES SYS\$1STORED\$1PROC\$1MESSAGES es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_PROCEDURE_MESSAGES.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra un ejemplo de salida de SYS\$1PROCEDURE\$1MESSAGES. ``` select transaction_id, query_id, record_time, log_level, trim(message), line_number from sys_procedure_messages; ``` ``` transaction_id | query_id | record_time | log_level | btrim | line_number ---------------+----------+----------------------------+-----------+---------------------------+------------- 25267 | 80562 | 2023-07-17 14:38:31.910136 | NOTICE | test_notice_msg_b9f1e749 | 8 25267 | 80562 | 2023-07-17 14:38:31.910002 | LOG | test_log_msg_833c7420 | 6 25267 | 80562 | 2023-07-17 14:38:31.910111 | INFO | test_info_msg_651373d9 | 7 25267 | 80562 | 2023-07-17 14:38:31.910154 | WARNING | test_warning_msg_831c5747 | 9 (4 rows) ``` # SYS\$1QUERY\$1DETAIL SYS\$1QUERY\$1DETAIL Utilice SYS\$1QUERY\$1DETAIL para visualizar los detalles de las consultas en los distintos niveles de las métricas, donde cada fila representa los detalles de una consulta de WLM en un nivel de la métrica determinado. Esta vista contiene muchos tipos de consultas como DDL, DML y comandos de utilidad (por ejemplo, copiar y descargar). Según el tipo de consulta, algunas columnas pueden resultar irrelevantes. Por ejemplo, external\$1scanned\$1bytes no es relevante para las tablas internas. SYS\$1QUERY\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). **nota** Para verificar si una transacción que contiene la consulta ejecutada se ha confirmado correctamente, debe realizar una operación de unión entre las tablas del sistema y la tabla `sys_transaction_history`. Por ejemplo: ``` SELECT th.transaction_id, qd.query_id, th.status AS transaction_status FROM sys_query_detail qd LEFT JOIN sys_query_history qh ON qd.query_id = qh.query_id LEFT JOIN sys_transaction_history th on qh.transaction_id = th.transaction_id; ``` ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_DETAIL.html) ## Notas de uso SYS\$1QUERY\$1DETAIL puede contener métricas en el paso, la secuencia, el segmento y la consulta secundaria. Además de hacer referencia a la columna metrics\$1level, puede ver qué nivel de métrica muestra una fila determinada haciendo referencia a los campos step\$1id, segment\$1id y stream\$1id según la siguiente tabla. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se devuelve el resultado de SYS\$1QUERY\$1DETAIL. La siguiente consulta muestra los detalles de metadatos de la consulta con respecto al paso, incluidos el nombre del paso, input\$1bytes, output\$1bytes, input\$1rows y output\$1rows. ``` SELECT query_id, child_query_sequence, stream_id, segment_id, step_id, trim(step_name) AS step_name, duration, input_bytes, output_bytes, input_rows, output_rows FROM sys_query_detail WHERE query_id IN (193929) ORDER BY query_id, stream_id, segment_id, step_id DESC; ``` Resultados de ejemplo. ``` query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | duration | input_bytes | output_bytes | input_rows | output_rows ----------+----------------------+-----------+------------+---------+------------+-----------------+-------------+--------------+------------+------------- 193929 | 2 | 0 | 0 | 3 | hash | 37144 | 0 | 9350272 | 0 | 292196 193929 | 5 | 0 | 0 | 3 | hash | 9492 | 0 | 23360 | 0 | 1460 193929 | 1 | 0 | 0 | 3 | hash | 46809 | 0 | 9350272 | 0 | 292196 193929 | 4 | 0 | 0 | 2 | return | 7685 | 0 | 896 | 0 | 112 193929 | 1 | 0 | 0 | 2 | project | 46809 | 0 | 0 | 0 | 292196 193929 | 2 | 0 | 0 | 2 | project | 37144 | 0 | 0 | 0 | 292196 193929 | 5 | 0 | 0 | 2 | project | 9492 | 0 | 0 | 0 | 1460 193929 | 3 | 0 | 0 | 2 | return | 11033 | 0 | 14336 | 0 | 112 193929 | 2 | 0 | 0 | 1 | project | 37144 | 0 | 0 | 0 | 292196 193929 | 1 | 0 | 0 | 1 | project | 46809 | 0 | 0 | 0 | 292196 193929 | 5 | 0 | 0 | 1 | project | 9492 | 0 | 0 | 0 | 1460 193929 | 3 | 0 | 0 | 1 | aggregate | 11033 | 0 | 201488 | 0 | 14 193929 | 4 | 0 | 0 | 1 | aggregate | 7685 | 0 | 28784 | 0 | 14 193929 | 5 | 0 | 0 | 0 | scan | 9492 | 0 | 23360 | 292196 | 1460 193929 | 4 | 0 | 0 | 0 | scan | 7685 | 0 | 1344 | 112 | 112 193929 | 2 | 0 | 0 | 0 | scan | 37144 | 0 | 7304900 | 292196 | 292196 193929 | 3 | 0 | 0 | 0 | scan | 11033 | 0 | 13440 | 112 | 112 193929 | 1 | 0 | 0 | 0 | scan | 46809 | 0 | 7304900 | 292196 | 292196 193929 | 5 | 0 | 0 | -1 | | 9492 | 12288 | 0 | 0 | 0 193929 | 1 | 0 | 0 | -1 | | 46809 | 16384 | 0 | 0 | 0 193929 | 2 | 0 | 0 | -1 | | 37144 | 16384 | 0 | 0 | 0 193929 | 4 | 0 | 0 | -1 | | 7685 | 28672 | 0 | 0 | 0 193929 | 3 | 0 | 0 | -1 | | 11033 | 114688 | 0 | 0 | 0 ``` Para ver las tablas de la base de datos ordenadas de las más utilizadas a las menos utilizadas, utilice el siguiente ejemplo. Reemplace *sample\$1data\$1dev* con su propia base de datos. Tenga en cuenta que esta consulta contará las consultas a partir del momento en que se cree el clúster, pero los datos de visualización del sistema no se guardarán cuando no haya espacio en el almacenamiento de datos. ``` SELECT table_name, COUNT (DISTINCT query_id) FROM SYS_QUERY_DETAIL WHERE table_name LIKE 'sample_data_dev%' GROUP BY table_name ORDER BY COUNT(*) DESC; +---------------------------------+-------+ | table_name | count | +---------------------------------+-------+ | sample_data_dev.tickit.venue | 4 | | sample_data_dev.myunload1.venue | 3 | | sample_data_dev.tickit.listing | 1 | | sample_data_dev.tickit.category | 1 | | sample_data_dev.tickit.users | 1 | | sample_data_dev.tickit.date | 1 | | sample_data_dev.tickit.sales | 1 | | sample_data_dev.tickit.event | 1 | +---------------------------------+-------+ ``` En el siguiente ejemplo, se muestran los distintos niveles de métricas de una única consulta de WLM. ``` SELECT query_id, child_query_sequence, stream_id, segment_id, step_id, step_name, start_time, end_time, metrics_level FROM sys_query_detail WHERE query_id = 1553 AND step_id = -1 ORDER BY stream_id, segment_id, step_id; query_id | child_query_sequence | stream_id | segment_id | step_id | step_name | start_time | end_time | metrics_level ----------+----------------------+-----------+------------+---------+-----------+----------------------------+----------------------------+--------------- 1553 | 1 | -1 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.847838 | child query 1553 | 1 | 0 | -1 | -1 | | 2024-10-17 02:28:49.814721 | 2024-10-17 02:28:49.835609 | stream 1553 | 1 | 0 | 0 | -1 | | 2024-10-17 02:28:49.824677 | 2024-10-17 02:28:49.830372 | segment 1553 | 1 | 1 | -1 | -1 | | 2024-10-17 02:28:49.835624 | 2024-10-17 02:28:49.845773 | stream 1553 | 1 | 1 | 1 | -1 | | 2024-10-17 02:28:49.84088 | 2024-10-17 02:28:49.842388 | segment 1553 | 1 | 1 | 2 | -1 | | 2024-10-17 02:28:49.835926 | 2024-10-17 02:28:49.844396 | segment 1553 | 1 | 2 | -1 | -1 | | 2024-10-17 02:28:49.846949 | 2024-10-17 02:28:49.847838 | stream 1553 | 1 | 2 | 3 | -1 | | 2024-10-17 02:28:49.847013 | 2024-10-17 02:28:49.847485 | segment (8 rows) ``` # SYS\$1QUERY\$1EXPLAIN SYS\$1QUERY\$1EXPLAIN Muestra el plan EXPLAIN de una consulta que se ha enviado para ejecutarse. SYS\$1QUERY\$1EXPLAIN es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_EXPLAIN.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo es el plan EXPLAIN de una sola consulta. ``` SELECT * FROM sys_query_explain WHERE query_id = 612635 ORDER BY plan_node_id; userid | query_id | child_query_sequence | plan_node_id | plan_parent_id | plan_node | plan_info --------+----------+----------------------+--------------+----------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ 100 | 612635 | 1 | 1 | 0 | XN Limit (cost=3604047533041.00..3604047533041.25 rows=100 width=20) | 100 | 612635 | 1 | 2 | 1 | -> XN Merge (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Merge Key: sum(b.totalprice) 100 | 612635 | 1 | 3 | 2 | -> XN Network (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Send to leader 100 | 612635 | 1 | 4 | 3 | -> XN Sort (cost=3604047533041.00..3604047533148.02 rows=42809 width=20) | Sort Key: sum(b.totalprice) 100 | 612635 | 1 | 5 | 4 | -> XN HashAggregate (cost=2604047529640.76..2604047529747.78 rows=42809 width=20) | 100 | 612635 | 1 | 6 | 5 | -> XN Hash Join DS_DIST_NONE (cost=15104956.16..2602364653507.34 rows=336575226684 width=20) | Hash Cond: (("outer".listid = "inner".listid) AND ("outer".sellerid = "inner".sellerid)) 100 | 612635 | 1 | 7 | 6 | -> XN Seq Scan on listing b (cost=0.00..7884677.12 rows=788467712 width=24) | 100 | 612635 | 1 | 8 | 6 | -> XN Hash (cost=7063797.76..7063797.76 rows=706379776 width=8) | 100 | 612635 | 1 | 9 | 8 | -> XN Seq Scan on sales a (cost=0.00..7063797.76 rows=706379776 width=8) | (9 rows) ``` # SYS\$1QUERY\$1HISTORY SYS\$1QUERY\$1HISTORY Utilice SYS\$1QUERY\$1HISTORY para visualizar los detalles de las consultas de los usuarios. Cada una de las filas representa una consulta del usuario con estadísticas acumuladas para algunos de los campos. Esta vista contiene muchos tipos de consultas, como por ejemplo lenguaje de definición de datos (DDL), lenguaje de manipulación de datos (DML), copia, descarga y Amazon Redshift Spectrum. Contiene tanto las consultas en curso como las que han finalizado. SYS\$1QUERY\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). **nota** Para verificar si una transacción que contiene la consulta ejecutada se ha confirmado correctamente, debe realizar una operación de unión entre las tablas del sistema y la tabla `sys_transaction_history`. Por ejemplo: ``` SELECT qh.transaction_id, qh.query_id, qh.status AS query_status, qh.query_type, TRIM(qh.query_text) AS query_text, th.status AS transaction_status FROM sys_query_history qh LEFT JOIN sys_transaction_history th ON qh.transaction_id = th.transaction_id; ``` ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_HISTORY.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve consultas en ejecución y en cola. ``` SELECT user_id, query_id, transaction_id, session_id, status, trim(database_name) AS database_name, start_time, end_time, result_cache_hit, elapsed_time, queue_time, execution_time FROM sys_query_history WHERE status IN ('running','queued') ORDER BY start_time; ``` Resultados de ejemplo. ``` user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time ---------+----------+----------------+------------+---------+---------------+---------------------------+----------------------------+------------------+--------------+------------+---------------- 101 | 760705 | 852337 | 1073832321 | running | tpcds_1t | 2022-02-15 19:03:19.67849 | 2022-02-15 19:03:19.739811 | f | 61321 | 0 | 0 ``` La siguiente consulta devuelve la hora de inicio, la hora de finalización, el tiempo en cola, el tiempo transcurrido, el tiempo de planificación y otros metadatos de una consulta específica. ``` SELECT user_id, query_id, transaction_id, session_id, status, trim(database_name) AS database_name, start_time, end_time, result_cache_hit, elapsed_time, queue_time, execution_time, planning_time, trim(query_text) as query_text FROM sys_query_history WHERE query_id = 3093; ``` Resultados de ejemplo. ``` user_id | query_id | transaction_id | session_id | status | database_name | start_time | end_time | result_cache_hit | elapsed_time | queue_time | execution_time | planning_time | query_text --------+----------+----------------+------------+------------+---------------+----------------------------+----------------------------+------------------+--------------+------------+----------------+---------------+------------------------------------- 106 | 3093 | 11759 | 1073750146 | success | dev | 2023-03-16 16:53:17.840214 | 2023-03-16 16:53:18.106588 | f | 266374 | 0 | 105725 | 136589 | select count(*) from item; ``` La siguiente consulta muestra las 10 consultas SELECT más recientes. ``` SELECT query_id, transaction_id, session_id, start_time, elapsed_time, queue_time, execution_time, returned_rows, returned_bytes FROM sys_query_history WHERE query_type = 'SELECT' ORDER BY start_time DESC limit 10; ``` Resultados de ejemplo. ``` query_id | transaction_id | session_id | start_time | elapsed_time | queue_time | execution_time | returned_rows | returned_bytes ----------+----------------+------------+----------------------------+--------------+------------+----------------+---------------+---------------- 526532 | 61093 | 1073840313 | 2022-02-09 04:43:24.149603 | 520571 | 0 | 481293 | 1 | 3794 526520 | 60850 | 1073840313 | 2022-02-09 04:38:27.24875 | 635957 | 0 | 596601 | 1 | 3679 526508 | 60803 | 1073840313 | 2022-02-09 04:37:51.118835 | 563882 | 0 | 503135 | 5 | 17216 526505 | 60763 | 1073840313 | 2022-02-09 04:36:48.636224 | 649337 | 0 | 589823 | 1 | 652 526478 | 60730 | 1073840313 | 2022-02-09 04:36:11.741471 | 14611321 | 0 | 14544058 | 0 | 0 526467 | 60636 | 1073840313 | 2022-02-09 04:34:11.91463 | 16711367 | 0 | 16633767 | 1 | 575 511617 | 617946 | 1074009948 | 2022-01-20 06:21:54.44481 | 9937090 | 0 | 9899271 | 100 | 12500 511603 | 617941 | 1074259415 | 2022-01-20 06:21:45.71744 | 8065081 | 0 | 7582500 | 100 | 8889 511595 | 617935 | 1074128320 | 2022-01-20 06:21:44.030876 | 1051270 | 0 | 1014879 | 1 | 72 511584 | 617931 | 1074030019 | 2022-01-20 06:21:42.764088 | 609033 | 0 | 485887 | 100 | 8438 ``` La siguiente consulta muestra el recuento diario de consultas select y el tiempo transcurrido promedio de consultas. ``` SELECT date_trunc('day',start_time) AS exec_day, status, COUNT(*) AS query_cnt, AVG(datediff (microsecond,start_time,end_time)) AS elapsed_avg FROM sys_query_history WHERE query_type = 'SELECT' AND start_time >= '2022-01-14' AND start_time <= '2022-01-18' GROUP BY exec_day, status ORDER BY exec_day, status; ``` Resultados de ejemplo. ``` exec_day | status | query_cnt | elapsed_avg ---------------------+---------+-----------+------------ 2022-01-14 00:00:00 | success | 5253 | 56608048 2022-01-15 00:00:00 | success | 7004 | 56995017 2022-01-16 00:00:00 | success | 5253 | 57016363 2022-01-17 00:00:00 | success | 5309 | 55236784 2022-01-18 00:00:00 | success | 8092 | 54355124 ``` La siguiente consulta muestra el rendimiento diario de tiempo transcurrido de consulta. ``` SELECT distinct date_trunc('day',start_time) AS exec_day, query_count.cnt AS query_count, Percentile_cont(0.5) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P50_runtime, Percentile_cont(0.8) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P80_runtime, Percentile_cont(0.9) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P90_runtime, Percentile_cont(0.99) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS P99_runtime, Percentile_cont(1.0) within group(ORDER BY elapsed_time) OVER (PARTITION BY exec_day) AS max_runtime FROM sys_query_history LEFT JOIN (SELECT date_trunc('day',start_time) AS day, count(*) cnt FROM sys_query_history WHERE query_type = 'SELECT' GROUP by 1) query_count ON date_trunc('day',start_time) = query_count.day WHERE query_type = 'SELECT' ORDER BY exec_day; ``` Resultados de ejemplo. ``` exec_day | query_count | p50_runtime | p80_runtime | p90_runtime | p99_runtime | max_runtime ---------------------+-------------+-------------+-------------+-------------+--------------+-------------- 2022-01-14 00:00:00 | 5253 | 16816922.0 | 69525096.0 | 158524917.8 | 486322477.52 | 1582078873.0 2022-01-15 00:00:00 | 7004 | 15896130.5 | 71058707.0 | 164314568.9 | 500331542.07 | 1696344792.0 2022-01-16 00:00:00 | 5253 | 15750451.0 | 72037082.2 | 159513733.4 | 480372059.24 | 1594793766.0 2022-01-17 00:00:00 | 5309 | 15394513.0 | 68881393.2 | 160254700.0 | 493372245.84 | 1521758640.0 2022-01-18 00:00:00 | 8092 | 15575286.5 | 68485955.4 | 154559572.5 | 463552685.39 | 1542783444.0 2022-01-19 00:00:00 | 5860 | 16648747.0 | 72470482.6 | 166485138.2 | 492038228.67 | 1693483241.0 2022-01-20 00:00:00 | 1751 | 15422072.0 | 69686381.0 | 162315385.0 | 497066615.00 | 1439319739.0 2022-02-09 00:00:00 | 13 | 6382812.0 | 17616161.6 | 21197988.4 | 23021343.84 | 23168439.0 ``` La siguiente consulta muestra la distribución de tipos de consulta. ``` SELECT query_type, COUNT(*) AS query_count FROM sys_query_history GROUP BY query_type ORDER BY query_count DESC; ``` Resultados de ejemplo. ``` query_type | query_count ------------+------------- UTILITY | 134486 SELECT | 38537 DDL | 4832 OTHER | 768 LOAD | 768 CTAS | 748 COMMAND | 92 ``` En el siguiente ejemplo, se muestra la diferencia en los resultados del hash de consulta entre varias consultas. Observe las siguientes consultas: ``` CREATE TABLE test_table (col1 INT); INSERT INTO test_table VALUES (1),(2); SELECT * FROM test_table; SELECT * FROM test_table; SELECT col1 FROM test_table; SELECT * FROM test_table WHERE col1=1; SELECT * FROM test_table WHERE col1=2; SELECT query_id, TRIM(user_query_hash) AS user_query_hash, TRIM(generic_query_hash) AS generic_query_hash, TRIM(query_text) AS text FROM sys_query_history ORDER BY start_time DESC LIMIT 10; ``` A continuación, se muestra un ejemplo de salida: ``` query_id | user_query_hash | generic_query_hash | text ---------+-----------------+--------------------+---------- 24723049 | oPuFtjEPLTs= | oPuFtjEPLTs= | select query_id, trim(user_query_hash) as user_query_hash, trim(generic_query_hash) as generic_query_hash, query_hash_version, trim(query_text) as text from sys_query_history order by start_time\r\ndesc limit 20 24723045 | Gw2Kwdd8m2I= | IwfRu8/XAKI= | select * from test_table where col1=2 limit 100 24723041 | LNw2vx0GDXo= | IwfRu8/XAKI= | select * from test_table where col1=1 limit 100 24723036 | H+qep/c82Y8= | H+qep/c82Y8= | select col1 from test_table limit 100 24723033 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100 24723029 | H+qep/c82Y8= | H+qep/c82Y8= | select * from test_table limit 100 24723023 | 50sirx9E1hU= | uO36Z1a/QYs= | insert into test_table values (1),(2) 24723021 | YSVnlivZHeo= | YSVnlivZHeo= | create table test_table (col1 int) ``` `SELECT * FROM test_table;` y `SELECT col1 FROM test_table;` tienen el mismo valor de user\$1query\$1hash, ya que test\$1table solo tiene una columna. `SELECT * FROM test_table WHERE col1=1;` y `SELECT * FROM test_table WHERE col1=2;` tienen valores de user\$1query\$1hash diferentes, pero valores de generic\$1query\$1hash idénticos, ya que las dos consultas son idénticas fuera de los literales de consulta 1 y 2. # SYS\$1QUERY\$1TEXT SYS\$1QUERY\$1TEXT Utilice SYS\$1QUERY\$1TEXT para ver el texto de todas las consultas. Cada fila representa el texto de las consultas de hasta 4000 caracteres que comienzan por el número de secuencia 0. Cuando la instrucción de consulta contiene más de 4000 caracteres, se registran filas adicionales para la instrucción al incrementar el número de secuencia de cada fila. Esta vista registra todo el texto de las consultas de los usuarios como las consultas de DDL, de utilidades, de Amazon Redshift y únicas del nodo principal. SYS\$1QUERY\$1TEXT es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_QUERY_TEXT.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve consultas en ejecución y en cola. ``` SELECT user_id, query_id, transaction_id, session_id, start_time, sequence, trim(text) as text from sys_query_text ORDER BY sequence; ``` Resultados de ejemplo. ``` user_id | query_id | transaction_id | session_id | start_time | sequence | text --------+----------+-----------------+------------+----------------------------+----------+---------------------------------------------------------------------------------------------------------------------- 100 | 4 | 1396 | 1073750220 | 2023-04-28 16:44:55.887184 | 0 | SELECT trim(text) as text, sequence FROM sys_query_text WHERE query_id = pg_last_query_id() AND user_id > 1 AND start _time > '2023-04-28 16:44:55.922705+00:00'::timestamp order by sequence; ``` La siguiente consulta devuelve los permisos concedidos o revocados a los grupos de la base de datos. ``` SELECT SPLIT_PART(text, ' ', 1) as grantrevoke, SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'GROUP'))), ' ', 2) as group, SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), ' '))), 'ON', 1) as type, SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 2) || ' ' || SPLIT_PART((SUBSTRING(text, STRPOS(UPPER(text), 'ON'))), ' ', 3) as entity FROM SYS_QUERY_TEXT WHERE (text LIKE 'GRANT%' OR text LIKE 'REVOKE%') AND text LIKE '%GROUP%'; +-------------+----------+--------+----------+ | grantrevoke | group | type | entity | +-------------+----------+--------+----------+ | GRANT | bi_group | SELECT | TABLE t1 | | GRANT | bi_group | SELECT | TABLE t1 | | GRANT | bi_group | SELECT | TABLE t1 | | GRANT | bi_group | USAGE | TABLE t1 | | GRANT | bi_group | SELECT | TABLE t1 | | GRANT | bi_group | SELECT | TABLE t1 | +-------------+----------+--------+----------+ ``` # SYS\$1REDSHIFT\$1TEMPLATE SYS\$1REDSHIFT\$1TEMPLATE Utilice SYS\$1REDSHIFT\$1TEMPLATE para ver los detalles de Redshift TEMPLATES. Esta vista contiene las TEMPLATES que se han creado. SYS\$1REDSHIFT\$1TEMPLATE es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_REDSHIFT_TEMPLATE.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve todas las plantillas visibles para el usuario actual: ``` SELECT * FROM SYS_REDSHIFT_TEMPLATE; ``` Resultados de ejemplo. ``` database_name | schema_name | template_name | template_type | create_time | last_modified_time | owner_id | last_modified_by | template_parameters ---------------+-------------+--------------------+---------------+----------------------------+----------------------------+----------+------------------+--------------------- dev | s1 | shapefile_template | 1 | 2025-12-17 22:42:02.079758 | 2025-12-17 22:42:02.079758 | 101 | 101 | { "SIMPLIFY_AUTO": 0.000001, "SHAPEFILE": 1, "COMPRESSION_UPDATE": 0 } dev | s2 | orc_template | 1 | 2025-12-17 22:42:23.582815 | 2025-12-17 22:42:23.582815 | 101 | 101 | { "ORC": "serializetojson_default" } dev | s1 | csv_template | 1 | 2025-12-17 22:43:01.822361 | 2025-12-17 22:43:01.822361 | 101 | 101 | { "ENCRYPTED": 1, "CSV": 1, "ENCODING": 1, "DELIMITER": "," } (3 rows) ``` # SYS\$1RESTORE\$1LOG SYS\$1RESTORE\$1LOG Utilice SYS\$1RESTORE\$1LOG para monitorear la evolución de la migración de cada tabla del clúster durante un cambio de tamaño clásico hacia los nodos RA3. Captura el rendimiento histórico de la migración de datos durante la operación de cambio de tamaño. Para obtener más información sobre el cambio de tamaño clásico hacia los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster). SYS\$1RESTORE\$1STATE solo es visible para los superusuarios. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_RESTORE_LOG.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta calcula el rendimiento del procesamiento de datos mediante SYS\$1RESTORE\$1LOG. ``` SELECT ROUND(sum(delta_data_processed) / 1024.0, 2) as data_processed_gb, ROUND(datediff(sec, min(event_time), max(event_time)) / 3600.0, 2) as duration_hr, ROUND(data_processed_gb/duration_hr, 2) as throughput_gb_per_hr from sys_restore_log; ``` Resultados de ejemplo. ``` data_processed_gb | duration_hr | throughput_gb_per_hr -------------------+-------------+---------------------- 0.91 | 8.37 | 0.11 (1 row) ``` La siguiente consulta muestra todos los tipos de redistribución. ``` SELECT * from sys_restore_log ORDER BY event_time; ``` ``` database_name | schema_name | table_name | table_id | action | total_data_processed | delta_data_processed | event_time | table_size | message | redistribution_type ---------------+----------------------+----------------------+----------+-----------------------------+----------------------+----------------------+----------------------------+------------+---------+-------------------------- dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution started | 0 | | 2024-01-05 02:18:00.744977 | 325 | | Restore Distkey Table dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution started | 0 | | 2024-01-05 02:18:02.756675 | 90 | | Restore Distkey Table dev | schemaaaa877096d844d | dp30907_t2_autokey | 106430 | Redistribution completed | 90 | 90 | 2024-01-05 02:23:30.643718 | 90 | | Restore Distkey Table dev | schemaaaa877096d844d | customer_key | 106424 | Redistribution completed | 325 | 325 | 2024-01-05 02:23:45.998249 | 325 | | Restore Distkey Table dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution started | 0 | | 2024-01-05 02:23:46.083849 | 30 | | Rebalance Disteven Table dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution started | 0 | | 2024-01-05 02:23:46.855728 | 45 | | Rebalance Disteven Table dev | schemaaaa877096d844d | dp30907_t5_auto_even | 106436 | Redistribution completed | 45 | 45 | 2024-01-05 02:24:16.343029 | 45 | | Rebalance Disteven Table dev | schemaaaa877096d844d | dp30907_t1_even | 106428 | Redistribution completed | 30 | 30 | 2024-01-05 02:24:20.584703 | 30 | | Rebalance Disteven Table dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution started | 0 | | 2024-01-05 04:54:55.641741 | 190 | | Restore Disteven Table dev | schemaefd028a2a48a4c | customer_even | 130512 | Redistribution checkpointed | 29.4342113157737 | 29.4342113157737 | 2024-01-05 04:55:04.770696 | 190 | | Restore Disteven Table (8 rows) ``` # SYS\$1RESTORE\$1STATE SYS\$1RESTORE\$1STATE Utilice SYS\$1RESTORE\$1STATE para monitorear la evolución de la migración de cada tabla durante un cambio de tamaño clásico. Esto es aplicable específicamente cuando el tipo de nodo de destino es RA3. Para obtener más información sobre el cambio de tamaño clásico hacia los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster). SYS\$1RESTORE\$1STATE solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_RESTORE_STATE.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve los registros para las consultas en ejecución y en cola. ``` SELECT * FROM sys_restore_state; ``` Resultados de ejemplo. ``` userid | database_name | schema_id | table_id | table_name | redistribution_status | precentage_redistributed | redistribution_type --------+---------------+-----------+----------+----------------+-----------------------+--------------------------+------------------------- 1 | test1 | 124865 | 124878 | customer_key_4 | Pending | 0 | Rebalance Disteven Table 1 | dev | 124865 | 124874 | customer_key_3 | Pending | 0 | Rebalance Disteven Table 1 | dev | 124865 | 124870 | customer_key_2 | Completed | 100 | Rebalance Disteven Table 1 | dev | 124865 | 124866 | customer_key_1 | In progress | 13.52 | Restore Distkey Table ``` A continuación se muestra el estado del procesamiento de datos. ``` SELECT redistribution_status, ROUND(SUM(block_count) / 1024.0, 2) AS total_size_gb FROM sys_restore_state sys inner join stv_tbl_perm stv on sys.table_id = stv.id GROUP BY sys.redistribution_status; ``` Resultados de ejemplo. ``` redistribution_status | total_size_gb -----------------------+--------------- Completed | 0.07 Pending | 0.71 In progress | 0.20 (3 rows) ``` # SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS Registra la incidencia, marca temporal, ID y otros datos útiles cuando se excede una cuota de esquema. Esta tabla del sistema es una traducción de [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md). r\$1SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_SCHEMA_QUOTA_VIOLATIONS.html) ## Consultas de ejemplo Consultas de ejemplo En la siguiente consulta se muestra el resultado de la infracción de cuota: ``` SELECT user_id, TRIM(schema_name) "schema_name", quota, disk_usage, record_time FROM sys_schema_quota_violations WHERE SCHEMA_NAME = 'sales_schema' ORDER BY timestamp DESC; ``` Esta consulta devuelve el siguiente resultado de ejemplo para el esquema especificado: ``` user_id| schema_name | quota | disk_usage | record_time -------+--------------+-------+------------+---------------------------- 104 | sales_schema | 2048 | 2798 | 2020-04-20 20:09:25.494723 (1 row) ``` # SYS\$1SERVERLESS\$1USAGE SYS\$1SERVERLESS\$1USAGE Utilice SYS\$1SERVERLESS\$1USAGE para ver los detalles del uso de los recursos de Amazon Redshift sin servidor. Esta vista del sistema no se aplica a los clústeres aprovisionados de Amazon Redshift. Esta vista contiene el resumen de uso sin servidor, incluidas la capacidad de computación utilizada para procesar consultas y la cantidad de almacenamiento administrado de Amazon Redshift que se utiliza con una precisión de 1 minuto. La capacidad de computación se mide en unidades de procesamiento Redshift (RPU) y se dosifica para las cargas de trabajo que se ejecutan en RPU por segundo. Las RPU se utilizan para procesar consultas sobre los datos cargados en el almacenamiento de datos, que se consultan desde un lago de datos de Amazon S3 o a los que se obtiene acceso desde las bases de datos operativas mediante una consulta federada. Amazon Redshift sin servidor conserva la información en SYS\$1SERVERLESS\$1USAGE durante 7 días. Para ver ejemplos de facturación de costos de computación, consulte [Facturación de Amazon Redshift sin servidor](https://docs.aws.amazon.com/redshift/latest/mgmt/serverless-billing.html). SYS\$1SERVERLESS\$1USAGE es visible para todos los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SERVERLESS_USAGE.html) ## Notas de uso Notas de uso + Hay situaciones en las que compute\$1seconds es 0 pero charged\$1seconds es mayor que 0 o viceversa. Este es un comportamiento normal debido a la forma en que se graban los datos en la vista del sistema. Para obtener una representación más precisa de los detalles del uso sin servidor, recomendamos agregar los datos. ## Ejemplo Ejemplo Para obtener el total de cargos por horas de RPU utilizadas durante un intervalo de tiempo mediante la consulta charged\$1seconds, ejecute la siguiente consulta: ``` select trunc(start_time) "Day", (sum(charged_seconds)/3600::double precision) * as cost_incurred from sys_serverless_usage group by 1 order by 1 ``` Tenga en cuenta que puede haber tiempo de inactividad durante el intervalo. El tiempo inactivo no se suma a las RPU consumidas. # SYS\$1SESSION\$1HISTORY SYS\$1SESSION\$1HISTORY Utilice SYS\$1SESSION\$1HISTORY para ver información sobre las sesiones activas actuales y el historial de sesiones. SYS\$1SESSION\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SESSION_HISTORY.html) ### Ejemplo Ejemplo A continuación se muestra un ejemplo de salida de SYS\$1SESSION\$1HISTORY. ``` select * from sys_session_history; user_id | session_id | database_name | status | session_timeout | start_time | end_time ---------+------------+------------------+--------+-----------------+----------------------------+---------------------------- 1 | 1073971370 | dev | closed | 0 | 2023-07-17 15:50:12.030104 | 2023-07-17 15:50:12.123218 1 | 1073979694 | dev | closed | 0 | 2023-07-17 15:50:24.117947 | 2023-07-17 15:50:24.131859 1 | 1073873049 | dev | closed | 0 | 2023-07-17 15:49:29.067398 | 2023-07-17 15:49:29.070294 1 | 1073873086 | database18127a4a | closed | 0 | 2023-07-17 15:49:29.119018 | 2023-07-17 15:49:29.125925 1 | 1073832112 | dev | closed | 0 | 2023-07-17 15:49:29.164688 | 2023-07-17 15:49:29.179631 1 | 1073987697 | dev | closed | 0 | 2023-07-17 15:49:29.26749 | 2023-07-17 15:49:29.273034 1 | 1073922429 | dev | closed | 0 | 2023-07-17 15:49:33.35315 | 2023-07-17 15:49:33.367499 1 | 1073766783 | dev | closed | 0 | 2023-07-17 15:49:45.38237 | 2023-07-17 15:49:45.396902 1 | 1073807506 | dev | active | 0 | 2023-07-17 15:51:48 | ``` # SYS\$1SPATIAL\$1SIMPLIFY SYS\$1SPATIAL\$1SIMPLIFY Puede consultar la vista del sistema SYS\$1SPATIAL\$1SIMPLIFY para obtener información acerca de los objetos de geometría espacial simplificada mediante el comando COPY. Cuando utiliza COPY en un shapefile, puede especificar las opciones de ingesta SIMPLIFY `tolerance`, SIMPLIFY AUTO y SIMPLIFY AUTO `max_tolerance`. El resultado de la simplificación se resume en la vista de sistema SYS\$1SPATIAL\$1SIMPLIFY. Cuando se configura SIMPLIFY AUTO `max_tolerance`, esta vista contiene una fila para cada geometría que excedió el tamaño máximo. Cuando se configura SIMPLIFY `tolerance`, se almacena una fila para toda la operación COPY. Esta fila referencia el ID de consulta COPY y la tolerancia de simplificación especificada. Para obtener más información sobre cómo cargar un shapefile, consulte [Carga de un shapefile en Amazon Redshift](spatial-copy-shapefile.md). SYS\$1SPATIAL\$1SIMPLIFY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_SPATIAL_SIMPLIFY.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve la lista de registros que COPY simplificó. ``` SELECT * FROM sys_spatial_simplify; query_id | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance ----------+-------------+-------------------+--------------+------------+------------+---------------------- 20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05 20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06 ``` # SYS\$1STREAM\$1SCAN\$1ERRORS SYS\$1STREAM\$1SCAN\$1ERRORS Registra los errores de los registros cargados mediante la ingesta de streaming. SYS\$1STREAM\$1SCAN\$1ERRORS es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_STREAM_SCAN_ERRORS.html) # SYS\$1STREAM\$1SCAN\$1STATES SYS\$1STREAM\$1SCAN\$1STATES Registra los estados de exploración de los registros cargados mediante la ingesta de streaming. SYS\$1STREAM\$1SCAN\$1STATES es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SYS_STREAM_SCAN_STATES.html) En la siguiente consulta se muestran los datos de flujo y de tema para consultas específicas. ``` select query_id,mv_name::varchar,external_schema_name::varchar,stream_name::varchar,sum(scanned_rows) total_records, sum(scanned_bytes) total_bytes from sys_stream_scan_states where query in (5401180,8601939) group by 1,2,3,4; query_id | mv_name | external_schema_name | stream_name | total_records | total_bytes ------------+----------------+----------------------+-----------------+---------------+---------------- 5401180 | kinesistest | kinesis | kinesisstream | 1493255696 | 3209006490704 8601939 | msktest | msk | mskstream | 14677023 | 31056580668 (2 rows) ``` # SYS\$1TRANSACTION\$1HISTORY SYS\$1TRANSACTION\$1HISTORY Utilice SYS\$1TRANSACTION\$1HISTORY para ver los detalles de una transacción al realizar el seguimiento de una consulta. SYS\$1TRANSACTION\$1HISTORY solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_TRANSACTION_HISTORY.html) ## Consultas de ejemplo ``` select * from sys_transaction_history order by transaction_start_time desc; user_id | transaction_id | isolation_level | status | transaction_start_time | commit_start_time | commit_end_time | blocks_committed | undo_transaction_id ---------+----------------+-----------------+------------+----------------------------+----------------------------+----------------------------+------------------+--------------------- 100 | 1310 | Serializable | committed | 2023-08-27 21:03:11.822205 | 2023-08-28 21:03:11.825287 | 2023-08-28 21:03:11.854883 | 17 | -1 101 | 1345 | Serializable | committed | 2023-08-27 21:03:12.000278 | 2023-08-28 21:03:12.003736 | 2023-08-28 21:03:12.030061 | 17 | -1 102 | 1367 | Serializable | committed | 2023-08-27 21:03:12.1532 | 2023-08-28 21:03:12.156124 | 2023-08-28 21:03:12.186468 | 17 | -1 100 | 1370 | Serializable | committed | 2023-08-27 21:03:12.199316 | 2023-08-28 21:03:12.204854 | 2023-08-28 21:03:12.238186 | 24 | -1 100 | 1408 | Serializable | committed | 2023-08-27 21:03:53.891107 | 2023-08-28 21:03:53.894825 | 2023-08-28 21:03:53.927465 | 17 | -1 100 | 1409 | Serializable | rolledback | 2023-08-27 21:03:53.936431 | 2000-01-01 00:00:00 | 2023-08-28 21:04:08.712532 | 0 | 1409 101 | 1415 | Serializable | committed | 2023-08-27 21:04:24.283188 | 2023-08-28 21:04:24.289196 | 2023-08-28 21:04:24.374318 | 25 | -1 101 | 1416 | Serializable | committed | 2023-08-27 21:04:24.38818 | 2023-08-28 21:04:24.391688 | 2023-08-28 21:04:24.415135 | 17 | -1 100 | 1417 | Serializable | rolledback | 2023-08-27 21:04:24.424252 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.354826 | 0 | 1417 101 | 1418 | Serializable | rolledback | 2023-08-27 21:04:24.425195 | 2000-01-01 00:00:00 | 2023-08-28 21:04:28.680355 | 0 | 1418 100 | 1420 | Serializable | committed | 2023-08-27 21:04:28.697607 | 2023-08-28 21:04:28.702374 | 2023-08-28 21:04:28.735541 | 23 | -1 101 | 1421 | Serializable | committed | 2023-08-27 21:04:28.744854 | 2023-08-28 21:04:28.749344 | 2023-08-28 21:04:28.779029 | 23 | -1 101 | 1423 | Serializable | committed | 2023-08-27 21:04:28.78942 | 2023-08-28 21:04:28.791556 | 2023-08-28 21:04:28.817485 | 16 | -1 100 | 1430 | Serializable | committed | 2023-08-27 21:04:28.917788 | 2023-08-28 21:04:28.919993 | 2023-08-28 21:04:28.944812 | 16 | -1 102 | 1494 | Serializable | committed | 2023-08-27 21:04:37.029058 | 2023-08-28 21:04:37.033137 | 2023-08-28 21:04:37.062001 | 16 | -1 ``` # SYS\$1UDF\$1LOG SYS\$1UDF\$1LOG Registra los mensajes de error y advertencia definidos por el sistema generados durante la ejecución de la función definida por el usuario (UDF). SYS\$1UDF\$1LOG solo está visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UDF_LOG.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra cómo las UDF administran los errores definidos por el sistema. El primer bloque muestra la definición para una función UDF que devuelve la inversa de un argumento. Si ejecuta la función y proporciona un 0 como argumento, la función devuelve un error. La última instrucción devuelve el mensaje de error registrado en SYS\$1UDF\$1LOG. ``` -- Create a function to find the inverse of a number. CREATE OR REPLACE FUNCTION f_udf_inv(a int) RETURNS float IMMUTABLE AS $$return 1/a $$ LANGUAGE plpythonu; -- Run the function with 0 to create an error. Select f_udf_inv(0); -- Query SYS_UDF_LOG to view the message. Select query_id, record_time, message::varchar from sys_udf_log; query_id | record_time | message ----------+----------------------------+------------------------------------------------------- 2211 | 2023-08-23 15:53:11.360538 | ZeroDivisionError: integer division or modulo by zero line 2, in f_udf_inv\n return 1/a\n ``` En el siguiente ejemplo, se agrega el registro y un mensaje de advertencia a la UDF para que una operación de división en cero dé como resultado un mensaje de advertencia, en lugar de parar con un mensaje de error. ``` -- Create a function to find the inverse of a number and log a warning if you input 0. CREATE OR REPLACE FUNCTION f_udf_inv_log(a int) RETURNS float IMMUTABLE AS $$ import logging logger = logging.getLogger() #get root logger if a==0: logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n') return 0 else: return 1/a $$ LANGUAGE plpythonu; -- Run the function with 0 to trigger the warning. Select f_udf_inv_log(0); -- Query SYS_UDF_LOG to view the message. Select query_id, record_time, message::varchar from sys_udf_log; query_id | record_time | message ----------+----------------------------+------------------------------------------------------------------------------- 0 | 2023-08-23 16:10:48.833503 | WARNING: You attempted to divide by zero.\nReturning zero instead of error.\n ``` # SYS\$1UNLOAD\$1DETAIL SYS\$1UNLOAD\$1DETAIL Utilice SYS\$1UNLOAD\$1TAIL para ver los detalles de la operación UNLOAD. Registra una fila por cada archivo creado por una instrucción UNLOAD. Por ejemplo, si una instrucción UNLOAD crea 12 archivos, SYS\$1UNLOAD\$1DETAIL contendrá 12 filas correspondientes. SYS\$1UNLOAD\$1DETAIL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UNLOAD_DETAIL.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra los detalles de la consulta descargada, incluidos el formato, las filas y el recuento de archivos del comando unload. ``` select query_id, substring(file_name, 0, 50), transfer_size, file_format from sys_unload_detail; ``` Resultados de ejemplo. ``` query_id | substring | transfer_size | file_format ----------+-------------------------------------------------------------+---------------+------------- 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0000_part_00.gz | 395886 | Text 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0001_part_00.gz | 406444 | Text 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0002_part_00.gz | 409431 | Text 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0003_part_00.gz | 403051 | Text 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0004_part_00.gz | 413592 | Text 9272 | s3://amzn-s3-demo-bucket/my_unload_doc_venue0005_part_00.gz | 395689 | Text (6 rows) ``` # SYS\$1UNLOAD\$1HISTORY SYS\$1UNLOAD\$1HISTORY Utilice SYS\$1UNLOAD\$1HISTORY para visualizar los detalles de los comandos UNLOAD. Cada una de las filas representa un comando UNLOAD con estadísticas acumuladas para algunos de los campos. Contiene tanto los comandos UNLOAD en ejecución como los que han finalizado. SYS\$1UNLOAD\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_UNLOAD_HISTORY.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta muestra los detalles de la consulta descargada, incluidos el formato, las filas y el recuento de archivos del comando unload. ``` SELECT query_id, file_format, start_time, duration, unloaded_rows, unloaded_files_count FROM sys_unload_history ORDER BY query_id, file_format limit 100; ``` Resultados de ejemplo. ``` query_id | file_format | start_time | duration | unloaded_rows | unloaded_files_count ----------+-------------+----------------------------+----------+---------------+---------------------- 527067 | Text | 2022-02-09 05:18:35.844452 | 5932478 | 10 | 1 ``` # SYS\$1USERLOG Registra detalles de los siguientes cambios realizados en un usuario de una base de datos: + Creación de usuario + Eliminación de usuario + Modificación de usuario (cambio de nombre) + Modificación de usuario (modificación de propiedades) Puede consultar esta vista para obtener información sobre los grupos de trabajo sin servidor y los clústeres aprovisionados. SYS\$1USERLOG solo es visible para los superusuarios. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_USERLOG.html) ## Consultas de ejemplo En el siguiente ejemplo, se realizan cuatro acciones del usuario y, luego, se consulta la vista SYS\$1USERLOG. ``` CREATE USER userlog1 password 'Userlog1'; ALTER USER userlog1 createdb createuser; ALTER USER userlog1 rename to userlog2; DROP user userlog2; SELECT user_id, user_name, original_user_name, action, has_create_db_privs, is_superuser from SYS_USERLOG order by record_time desc; ``` ``` user_id | user_name | original_user_name | action | has_create_db_privs | is_superuser --------+------------+--------------------+---------+---------------------+------------ 108 | userlog2 | | drop | 1 | 1 108 | userlog2 | userlog1 | rename | 1 | 1 108 | userlog1 | | alter | 1 | 1 108 | userlog1 | | create | 0 | 0 (4 rows) ``` # SYS\$1VACUUM\$1HISTORY SYS\$1VACUUM\$1HISTORY Utilice SYS\$1VACUUM\$1HISTORY para visualizar los detalles de las consultas de los usuarios. Para obtener información sobre el comando VACUUM, consulte [VACUUM](r_VACUUM_command.md). SYS\$1VACUUM\$1HISTORY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/SYS_VACUUM_HISTORY.html) # Asignación de la vista de sistema para migrar a las vistas de supervisión SYS Asignación de la vista de sistema para migrar a las vistas de supervisión SYS Al migrar su clúster de Amazon Redshift aprovisionado a Amazon Redshift sin servidor, es posible que sus consultas de monitorización o diagnóstico hagan referencia a vistas del sistema que solo están disponibles en clústeres aprovisionados. Puede actualizar sus consultas para utilizar las vistas de monitorización SYS. Esta página proporciona asignaciones de vistas aprovisionadas solo a SYS para que pueda consultarlas cuando actualice las consultas. **Topics** + [ ## SYS\$1QUERY\$1HISTORY ](#sys_view_migration-SYS_QUERY_HISTORY) + [ ## SYS\$1QUERY\$1DETAIL ](#sys_view_migration-SYS_QUERY_DETAIL) + [ ## SYS\$1RESTORE\$1LOG ](#sys_view_migration-SYS_RESTORE_LOG) + [ ## SYS\$1RESTORE\$1STATE ](#sys_view_migration-SYS_RESTORE_STATE) + [ ## SYS\$1TRANSACTION\$1HISTORY ](#sys_view_migration-SYS_TRANSACTION_HISTORY) + [ ## SYS\$1QUERY\$1TEXT ](#sys_view_migration-SYS_QUERY_TEXT) + [ ## SYS\$1CONNECTION\$1LOG ](#sys_view_migration-SYS_CONNECTION_LOG) + [ ## SYS\$1SESSION\$1HISTORY ](#sys_view_migration-SYS_SESSION_HISTORY) + [ ## SYS\$1LOAD\$1DETAIL ](#sys_view_migration-SYS_LOAD_DETAIL) + [ ## SYS\$1LOAD\$1HISTORY ](#sys_view_migration-SYS_LOAD_HISTORY) + [ ## SYS\$1LOAD\$1ERROR\$1DETAIL ](#sys_view_migration-SYS_LOAD_ERROR_DETAIL) + [ ## SYS\$1UNLOAD\$1HISTORY ](#sys_view_migration-SYS_UNLOAD_HISTORY) + [ ## SYS\$1UNLOAD\$1DETAIL ](#sys_view_migration-SYS_UNLOAD_DETAIL) + [ ## SYS\$1COPY\$1REPLACEMENTS ](#sys_view_migration-SYS_COPY_REPLACEMENTS) + [ ## SYS\$1DATASHARE\$1USAGE\$1CONSUMER ](#sys_view_migration-SYS_DATASHARE_USAGE_CONSUMER) + [ ## SYS\$1DATASHARE\$1USAGE\$1PRODUCER ](#sys_view_migration-SYS_DATASHARE_USAGE_PRODUCER) + [ ## SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE ](#sys_view_migration-SYS_DATASHARE_CROSS_REGION_USAGE) + [ ## SYS\$1DATASHARE\$1CHANGE\$1LOG ](#sys_view_migration-SYS_DATASHARE_CHANGE_LOG) + [ ## SYS\$1EXTERNAL\$1QUERY\$1DETAIL ](#sys_view_migration-SYS_EXTERNAL_QUERY_DETAIL) + [ ## SYS\$1EXTERNAL\$1QUERY\$1ERROR ](#sys_view_migration-SYS_EXTERNAL_QUERY_ERROR) + [ ## SYS\$1VACUUM\$1HISTORY ](#sys_view_migration-SYS_VACUUM_HISTORY) + [ ## SYS\$1ANALYZE\$1HISTORY ](#sys_view_migration-SYS_ANALYZE_HISTORY) + [ ## SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY ](#sys_view_migration-SYS_ANALYZE_COMPRESSION_HISTORY) + [ ## SYS\$1MV\$1REFRESH\$1HISTORY ](#sys_view_migration-SYS_MV_REFRESH_HISTORY) + [ ## SYS\$1MV\$1STATE ](#sys_view_migration-SYS_MV_STATE) + [ ## SYS\$1PROCEDURE\$1CALL ](#sys_view_migration-SYS_PROCEDURE_CALL) + [ ## SYS\$1PROCEDURE\$1MESSAGES ](#sys_view_migration-SYS_PROCEDURE_MESSAGES) + [ ## SYS\$1UDF\$1LOG ](#sys_view_migration-SYS_UDF_LOG) + [ ## SYS\$1USERLOG ](#sys_view_migration-SYS_USERLOG) + [ ## SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS ](#sys_view_migration-SYS_SCHEMA_QUOTA_VIOLATIONS) + [ ## SYS\$1SPATIAL\$1SIMPLIFY ](#sys_view_migration-SYS_SPATIAL_SIMPLIFY) ## SYS\$1QUERY\$1HISTORY SYS\$1QUERY\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1QUERY\$1HISTORY](SYS_QUERY_HISTORY.md). + [STL\$1DDLTEXT](r_STL_DDLTEXT.md) + [STL\$1ERROR](r_STL_ERROR.md) + [STL\$1QUERY](r_STL_QUERY.md) + [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md) + [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md) + [STV\$1INFLIGHT](r_STV_INFLIGHT.md) + [STV\$1RECENTS](r_STV_RECENTS.md) + [STV\$1WLM\$1QUERY\$1STATE](r_STV_WLM_QUERY_STATE.md) + [SVL\$1COMPILE](r_SVL_COMPILE.md) + [SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS](r_SVL_MULTI_STATEMENT_VIOLATIONS.md) + [SVL\$1QLOG](r_SVL_QLOG.md) + [SVL\$1QUERY\$1QUEUE\$1INFO](r_SVL_QUERY_QUEUE_INFO.md) + [SVL\$1STATEMENTTEXT](r_SVL_STATEMENTTEXT.md) + [SVL\$1TERMINATE](r_SVL_TERMINATE.md) ## SYS\$1QUERY\$1DETAIL SYS\$1QUERY\$1DETAIL Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1QUERY\$1DETAIL](SYS_QUERY_DETAIL.md). + [STL\$1AGGR](r_STL_AGGR.md) + [STL\$1ALERT\$1EVENT\$1LOG](r_STL_ALERT_EVENT_LOG.md) + [STL\$1BCAST](r_STL_BCAST.md) + [STL\$1DELETE](r_STL_DELETE.md) + [STL\$1DIST](r_STL_DIST.md) + [STL\$1EXPLAIN](r_STL_EXPLAIN.md) + [STL\$1HASH](r_STL_HASH.md) + [STL\$1HASHJOIN](r_STL_HASHJOIN.md) + [STL\$1INSERT](r_STL_INSERT.md) + [STL\$1LIMIT](r_STL_LIMIT.md) + [STL\$1MERGE](r_STL_MERGE.md) + [STL\$1MERGEJOIN](r_STL_MERGEJOIN.md) + [STL\$1NESTLOOP](r_STL_NESTLOOP.md) + [STL\$1PARSE](r_STL_PARSE.md) + [STL\$1PLAN\$1INFO](r_STL_PLAN_INFO.md) + [STL\$1PROJECT](r_STL_PROJECT.md) + [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md) + [STL\$1RETURN](r_STL_RETURN.md) + [STL\$1SAVE](r_STL_SAVE.md) + [STL\$1SCAN](r_STL_SCAN.md) + [STL\$1SORT](r_STL_SORT.md) + [STL\$1STREAM\$1SEGS](r_STL_STREAM_SEGS.md) + [STL\$1UNIQUE](r_STL_UNIQUE.md) + [STL\$1WINDOW](r_STL_WINDOW.md) + [STV\$1EXEC\$1STATE](r_STV_EXEC_STATE.md) + [STV\$1QUERY\$1METRICS](r_STV_QUERY_METRICS.md) + [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md) + [SVL\$1QUERY\$1METRICS](r_SVL_QUERY_METRICS.md) + [SVL\$1QUERY\$1METRICS\$1SUMMARY](r_SVL_QUERY_METRICS_SUMMARY.md) + [SVL\$1QUERY\$1REPORT](r_SVL_QUERY_REPORT.md) + [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md) + [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md) ## SYS\$1RESTORE\$1LOG SYS\$1RESTORE\$1LOG Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1RESTORE\$1LOG](SYS_RESTORE_LOG.md). + [SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS](r_SVL_RESTORE_ALTER_TABLE_PROGRESS.md) ## SYS\$1RESTORE\$1STATE SYS\$1RESTORE\$1STATE Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1RESTORE\$1STATE](SYS_RESTORE_STATE.md). + [STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE](r_STV_XRESTORE_ALTER_QUEUE_STATE.md) ## SYS\$1TRANSACTION\$1HISTORY SYS\$1TRANSACTION\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1TRANSACTION\$1HISTORY](SYS_TRANSACTION_HISTORY.md). + [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md) + [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md) + [STL\$1UNDONE](r_STL_UNDONE.md) ## SYS\$1QUERY\$1TEXT SYS\$1QUERY\$1TEXT Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1QUERY\$1TEXT](SYS_QUERY_TEXT.md). + [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) ## SYS\$1CONNECTION\$1LOG SYS\$1CONNECTION\$1LOG Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1CONNECTION\$1LOG](SYS_CONNECTION_LOG.md). + [STL\$1CONNECTION\$1LOG](r_STL_CONNECTION_LOG.md) ## SYS\$1SESSION\$1HISTORY SYS\$1SESSION\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1SESSION\$1HISTORY](SYS_SESSION_HISTORY.md). + [STL\$1SESSIONS](r_STL_SESSIONS.md) + [STL\$1RESTARTED\$1SESSIONS](r_STL_RESTARTED_SESSIONS.md) + [STV\$1SESSIONS](r_STV_SESSIONS.md) ## SYS\$1LOAD\$1DETAIL SYS\$1LOAD\$1DETAIL Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1LOAD\$1DETAIL](SYS_LOAD_DETAIL.md). + [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md) ## SYS\$1LOAD\$1HISTORY SYS\$1LOAD\$1HISTORY Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1LOAD\$1HISTORY](SYS_LOAD_HISTORY.md). + [STL\$1LOAD\$1COMMITS](r_STL_LOAD_COMMITS.md) ## SYS\$1LOAD\$1ERROR\$1DETAIL SYS\$1LOAD\$1ERROR\$1DETAIL Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1LOAD\$1ERROR\$1DETAIL](SYS_LOAD_ERROR_DETAIL.md). + [STL\$1LOADERROR\$1DETAIL](r_STL_LOADERROR_DETAIL.md) + [STL\$1LOAD\$1ERRORS](r_STL_LOAD_ERRORS.md) ## SYS\$1UNLOAD\$1HISTORY SYS\$1UNLOAD\$1HISTORY Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1UNLOAD\$1HISTORY](SYS_UNLOAD_HISTORY.md). + [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md) ## SYS\$1UNLOAD\$1DETAIL SYS\$1UNLOAD\$1DETAIL Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1UNLOAD\$1DETAIL](SYS_UNLOAD_DETAIL.md). + [STL\$1UNLOAD\$1LOG](r_STL_UNLOAD_LOG.md) ## SYS\$1COPY\$1REPLACEMENTS SYS\$1COPY\$1REPLACEMENTS Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1COPY\$1REPLACEMENTS](SYS_COPY_REPLACEMENTS.md). + [STL\$1REPLACEMENTS](r_STL_REPLACEMENTS.md) ## SYS\$1DATASHARE\$1USAGE\$1CONSUMER SYS\$1DATASHARE\$1USAGE\$1CONSUMER Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.md). + [SVL\$1DATASHARE\$1USAGE\$1CONSUMER](r_SVL_DATASHARE_USAGE_CONSUMER.md) ## SYS\$1DATASHARE\$1USAGE\$1PRODUCER SYS\$1DATASHARE\$1USAGE\$1PRODUCER Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.md). + [SVL\$1DATASHARE\$1USAGE\$1PRODUCER](r_SVL_DATASHARE_USAGE_PRODUCER.md) ## SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.md). + [SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SVL_DATASHARE_CROSS_REGION_USAGE.md) ## SYS\$1DATASHARE\$1CHANGE\$1LOG SYS\$1DATASHARE\$1CHANGE\$1LOG Algunas o todas las columnas de la tabla siguiente también están definidas en [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_LOG.md). + [SVL\$1DATASHARE\$1CHANGE\$1LOG](r_SVL_DATASHARE_CHANGE_LOG.md) ## SYS\$1EXTERNAL\$1QUERY\$1DETAIL SYS\$1EXTERNAL\$1QUERY\$1DETAIL Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_QUERY_DETAIL.md). + [SVL\$1FEDERATED\$1QUERY](r_SVL_FEDERATED_QUERY.md) + [SVL\$1S3LIST](r_SVL_S3LIST.md) + [SVL\$1S3QUERY](r_SVL_S3QUERY.md) + [SVL\$1S3QUERY\$1SUMMARY](r_SVL_S3QUERY_SUMMARY.md) ## SYS\$1EXTERNAL\$1QUERY\$1ERROR SYS\$1EXTERNAL\$1QUERY\$1ERROR Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.md). + [SVL\$1SPECTRUM\$1SCAN\$1ERROR](r_SVL_SPECTRUM_SCAN_ERROR.md) ## SYS\$1VACUUM\$1HISTORY SYS\$1VACUUM\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1VACUUM\$1HISTORY](SYS_VACUUM_HISTORY.md). + [STL\$1VACUUM](r_STL_VACUUM.md) + [SVL\$1VACUUM\$1PERCENTAGE](r_SVL_VACUUM_PERCENTAGE.md) + [SVV\$1VACUUM\$1PROGRESS](r_SVV_VACUUM_PROGRESS.md) + [SVV\$1VACUUM\$1SUMMARY](r_SVV_VACUUM_SUMMARY.md) ## SYS\$1ANALYZE\$1HISTORY SYS\$1ANALYZE\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1ANALYZE\$1HISTORY](SYS_ANALYZE_HISTORY.md). + [STL\$1ANALYZE](r_STL_ANALYZE.md) ## SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1ANALYZE\$1COMPRESSION\$1HISTORY](r_SYS_ANALYZE_COMPRESSION_HISTORY.md). + [STL\$1ANALYZE\$1COMPRESSION](r_STL_ANALYZE_COMPRESSION.md) ## SYS\$1MV\$1REFRESH\$1HISTORY SYS\$1MV\$1REFRESH\$1HISTORY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1MV\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_HISTORY.md). + [SVL\$1MV\$1REFRESH\$1STATUS](r_SVL_MV_REFRESH_STATUS.md) ## SYS\$1MV\$1STATE SYS\$1MV\$1STATE Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1MV\$1STATE](SYS_MV_STATE.md). + [STL\$1MV\$1STATE](r_STL_MV_STATE.md) ## SYS\$1PROCEDURE\$1CALL SYS\$1PROCEDURE\$1CALL Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.md). + [SVL\$1STORED\$1PROC\$1CALL](r_SVL_STORED_PROC_CALL.md) ## SYS\$1PROCEDURE\$1MESSAGES SYS\$1PROCEDURE\$1MESSAGES Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.md). + [SVL\$1STORED\$1PROC\$1MESSAGES](r_SVL_STORED_PROC_MESSAGES.md) ## SYS\$1UDF\$1LOG SYS\$1UDF\$1LOG Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1UDF\$1LOG](SYS_UDF_LOG.md). + [SVL\$1UDF\$1LOG](r_SVL_UDF_LOG.md) ## SYS\$1USERLOG SYS\$1USERLOG Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1USERLOG](SYS_USERLOG.md). + [STL\$1USERLOG](r_STL_USERLOG.md) ## SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_SYS_SCHEMA_QUOTA_VIOLATIONS.md). + [STL\$1SCHEMA\$1QUOTA\$1VIOLATIONS](r_STL_SCHEMA_QUOTA_VIOLATIONS.md) ## SYS\$1SPATIAL\$1SIMPLIFY SYS\$1SPATIAL\$1SIMPLIFY Algunas o todas las columnas de las tablas siguientes también están definidas en [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.md). + [SVL\$1SPATIAL\$1SIMPLIFY](r_SVL_SPATIAL_SIMPLIFY.md) # Monitoreo del sistema (solo aprovisionado) Monitoreo del sistema (solo aprovisionado) Se pueden consultar las siguientes tablas y vistas del sistema en los clústeres aprovisionados. Las vistas y tablas STL y STV incluyen un subconjunto de datos que se encuentra en distintas tablas de sistema. Estas vistas y tablas proporcionan un acceso más rápido y fácil a los datos más consultados que se encuentran en esas tablas. Las vistas SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas SVL proporcionan información solo para las consultas que se ejecutan en el clúster principal, con la excepción de SVL\$1STATEMENTTEXT. SVL\$1STATEMENTTEXT puede contener información para consultas ejecutadas en clústeres de escalado simultáneo, así como en el clúster principal. **Topics** + [ # Vistas STL para registro ](c_intro_STL_tables.md) + [ # Tablas STV para datos de instantáneas ](c_intro_STV_tables.md) + [ # Vistas de SVCS para clústeres de escalado principales y de simultaneidad ](svcs_views.md) + [ # Vistas de SVL para el clúster principal ](svl_views.md) # Vistas STL para registro 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 Consulta 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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) ``` # Tablas STV para datos de instantáneas Tablas STV para datos de instantáneas Las tablas de STV son tablas de sistema virtuales que tienen instantáneas de los datos actuales del sistema. **Topics** + [ # STV\$1ACTIVE\$1CURSORS ](r_STV_ACTIVE_CURSORS.md) + [ # STV\$1BLOCKLIST ](r_STV_BLOCKLIST.md) + [ # STV\$1CURSOR\$1CONFIGURATION ](r_STV_CURSOR_CONFIGURATION.md) + [ # STV\$1DB\$1ISOLATION\$1LEVEL ](r_STV_DB_ISOLATION_LEVEL.md) + [ # STV\$1EXEC\$1STATE ](r_STV_EXEC_STATE.md) + [ # STV\$1INFLIGHT ](r_STV_INFLIGHT.md) + [ # STV\$1LOAD\$1STATE ](r_STV_LOAD_STATE.md) + [ # STV\$1LOCKS ](r_STV_LOCKS.md) + [ # STV\$1ML\$1MODEL\$1INFO ](r_STV_ML_MODEL_INFO.md) + [ # STV\$1MV\$1DEPS ](r_STV_MV_DEPS.md) + [ # STV\$1MV\$1INFO ](r_STV_MV_INFO.md) + [ # STV\$1NODE\$1STORAGE\$1CAPACITY ](r_STV_NODE_STORAGE_CAPACITY.md) + [ # STV\$1PARTITIONS ](r_STV_PARTITIONS.md) + [ # STV\$1QUERY\$1METRICS ](r_STV_QUERY_METRICS.md) + [ # STV\$1RECENTS ](r_STV_RECENTS.md) + [ # STV\$1SESSIONS ](r_STV_SESSIONS.md) + [ # STV\$1SLICES ](r_STV_SLICES.md) + [ # STV\$1STARTUP\$1RECOVERY\$1STATE ](r_STV_STARTUP_RECOVERY_STATE.md) + [ # STV\$1TBL\$1PERM ](r_STV_TBL_PERM.md) + [ # STV\$1TBL\$1TRANS ](r_STV_TBL_TRANS.md) + [ # STV\$1WLM\$1CLASSIFICATION\$1CONFIG ](r_STV_WLM_CLASSIFICATION_CONFIG.md) + [ # STV\$1WLM\$1QMR\$1CONFIG ](r_STV_WLM_QMR_CONFIG.md) + [ # STV\$1WLM\$1QUERY\$1QUEUE\$1STATE ](r_STV_WLM_QUERY_QUEUE_STATE.md) + [ # STV\$1WLM\$1QUERY\$1STATE ](r_STV_WLM_QUERY_STATE.md) + [ # STV\$1WLM\$1QUERY\$1TASK\$1STATE ](r_STV_WLM_QUERY_TASK_STATE.md) + [ # STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG ](r_STV_WLM_SERVICE_CLASS_CONFIG.md) + [ # STV\$1WLM\$1SERVICE\$1CLASS\$1STATE ](r_STV_WLM_SERVICE_CLASS_STATE.md) + [ # STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE ](r_STV_XRESTORE_ALTER_QUEUE_STATE.md) # STV\$1ACTIVE\$1CURSORS STV\$1ACTIVE\$1CURSORS STV\$1ACTIVE\$1CURSORS muestra los detalles de los cursores que están abiertos actualmente. Para obtener más información, consulte [DECLARE](declare.md). Todos los usuarios pueden ver STV\$1ACTIVE\$1CURSORS. 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). Un usuario solo puede ver los cursores que él mismo haya abierto. Un superusuario puede ver todos los cursores. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_ACTIVE_CURSORS.html) # STV\$1BLOCKLIST STV\$1BLOCKLIST STV\$1BLOCKLIST tiene la cantidad de bloques de 1 MB de disco que utiliza cada sector, tabla o columna en una base de datos. Utilice consultas de agregación con STV\$1BLOCKLIST, como se muestra en los siguientes ejemplos, para determinar la cantidad de bloques de 1 MB de disco asignados para cada base de datos, tabla, sector o columna. También puede utilizar [STV\$1PARTITIONS](r_STV_PARTITIONS.md) para obtener información resumida acerca de la utilización del disco. Solo los superusuarios pueden ver STV\$1BLOCKLIST. 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** STV\$1BLOCKLIST solo registra los bloques que pertenecen al clúster aprovisionado o al espacio de nombres sin servidor. Si la base de datos incluye bloques compartidos de un productor de recursos compartidos de datos, esos bloques no se incluyen en STV\$1BLOCKLIST. Para obtener más información acerca de los recursos compartidos de datos, vaya a [Uso compartido de datos en Amazon Redshift](datashare-overview.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_BLOCKLIST.html) ## Consultas de ejemplo Consultas de ejemplo STV\$1BLOCKLIST tiene una fila por cada bloque del disco designado, por lo que una consulta que selecciona todas las filas posiblemente devuelva una gran cantidad de filas. Le recomendamos usar solo las consultas de agregación con STV\$1BLOCKLIST. La vista [SVV\$1DISKUSAGE](r_SVV_DISKUSAGE.md) proporciona información similar en un formato más sencillo de usar. Sin embargo, en el siguiente ejemplo se demuestra un uso de la tabla STV\$1BLOCKLIST. Para determinar la cantidad de bloques de 1 MB que utiliza cada columna de la tabla VENUE, escriba la siguiente consulta: ``` select col, count(*) from stv_blocklist, stv_tbl_perm where stv_blocklist.tbl = stv_tbl_perm.id and stv_blocklist.slice = stv_tbl_perm.slice and stv_tbl_perm.name = 'venue' group by col order by col; ``` Esta consulta devuelve la cantidad de bloques de 1 MB asignados a cada columna de la tabla VENUE, tal como se muestra en los siguientes datos de ejemplo: ``` col | count -----+------- 0 | 4 1 | 4 2 | 4 3 | 4 4 | 4 5 | 4 7 | 4 8 | 4 (8 rows) ``` En la siguiente consulta, se muestra si una tabla está distribuida en todos los sectores: ``` select trim(name) as table, stv_blocklist.slice, stv_tbl_perm.rows from stv_blocklist,stv_tbl_perm where stv_blocklist.tbl=stv_tbl_perm.id and stv_tbl_perm.slice=stv_blocklist.slice and stv_blocklist.id > 10000 and name not like '%#m%' and name not like 'systable%' group by name, stv_blocklist.slice, stv_tbl_perm.rows order by 3 desc; ``` Esta consulta produce el siguiente ejemplo de salida, que muestra una distribución uniforme de los datos en la tabla que tiene la mayor cantidad de filas: ``` table | slice | rows ----------+-------+------- listing | 13 | 10527 listing | 14 | 10526 listing | 8 | 10526 listing | 9 | 10526 listing | 7 | 10525 listing | 4 | 10525 listing | 17 | 10525 listing | 11 | 10525 listing | 5 | 10525 listing | 18 | 10525 listing | 12 | 10525 listing | 3 | 10525 listing | 10 | 10525 listing | 2 | 10524 listing | 15 | 10524 listing | 16 | 10524 listing | 6 | 10524 listing | 19 | 10524 listing | 1 | 10523 listing | 0 | 10521 ... (180 rows) ``` La siguiente consulta determina si hay algún bloque del tipo tombstone confirmado en el disco: ``` select slice, col, tbl, blocknum, newblock from stv_blocklist where tombstone > 0; slice | col | tbl | blocknum | newblock -------+-----+--------+----------+---------- 4 | 0 | 101285 | 0 | 1 4 | 2 | 101285 | 0 | 1 4 | 4 | 101285 | 1 | 1 5 | 2 | 101285 | 0 | 1 5 | 0 | 101285 | 0 | 1 5 | 1 | 101285 | 0 | 1 5 | 4 | 101285 | 1 | 1 ... (24 rows) ``` # STV\$1CURSOR\$1CONFIGURATION STV\$1CURSOR\$1CONFIGURATION STV\$1CURSOR\$1CONFIGURATION muestra las restricciones de la configuración del cursor. Para obtener más información, consulte [Restricciones del cursor](declare.md#declare-constraints). Solo los superusuarios pueden ver STV\$1CURSOR\$1CONFIGURATION. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_CURSOR_CONFIGURATION.html) # STV\$1DB\$1ISOLATION\$1LEVEL STV\$1DB\$1ISOLATION\$1LEVEL STV\$1DB\$1ISOLATION\$1LEVEL muestra el nivel de aislamiento actual de las bases de datos. Para obtener más información acerca de los niveles de aislamiento, consulte [Niveles de aislamiento en Amazon Redshift](c_serial_isolation.md). STV\$1DB\$1ISOLATION\$1LEVEL 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_DB_ISOLATION_LEVEL.html) # STV\$1EXEC\$1STATE STV\$1EXEC\$1STATE Utilice la tabla STV\$1EXEC\$1STATE para encontrar información acerca de las consultas y los pasos de consultas que se están ejecutando de forma activa en los nodos de computación. Esta información suele utilizarse solo para solucionar problemas de ingeniería. Las vistas SVV\$1QUERY\$1STATE y SVL\$1QUERY\$1SUMMARY extraen la información de STV\$1EXEC\$1STATE. Todos los usuarios pueden ver STV\$1EXEC\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_EXEC_STATE.html) ## Consultas de ejemplo Consultas de ejemplo En lugar de consultar la tabla STV\$1EXEC\$1STATE directamente, Amazon Redshift recomienda consultar SVL\$1QUERY\$1SUMMARY o SVV\$1QUERY\$1STATE para obtener la información de STV\$1EXEC\$1STATE en un formato más fácil de usar. Consulte la tabla [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md) o la documentación de la tabla [SVV\$1QUERY\$1STATE](r_SVV_QUERY_STATE.md) para obtener más detalles. # STV\$1INFLIGHT STV\$1INFLIGHT Utilice la tabla STV\$1INFLIGHT para determinar cuáles son las consultas que se están ejecutando en el clúster. Si está solucionando problemas, resulta útil para comprobar el estado de las consultas de larga duración. STV\$1INFLIGHT no muestra las consultas únicas del nodo principal. Para obtener más información, consulte [Funciones específicas del nodo principal](c_SQL_functions_leader_node_only.md). Todos los usuarios pueden ver STV\$1INFLIGHT. 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. ## Solución de problemas con STV\$1INFLIGHT Solución de problemas con STV\$1INFLIGHT Si utiliza STV\$1INFLIGHT para solucionar problemas de rendimiento de una consulta o de una colección de consultas, tenga en cuenta lo siguiente: + Las transacciones abiertas de larga duración suelen aumentar la carga. Estas transacciones abiertas pueden dar lugar a tiempos de ejecución más largos para otras consultas. + Los trabajos COPY y ETL de larga duración pueden afectar a otras consultas que se ejecuten en el clúster, si están consumiendo muchos recursos de computación. En la mayoría de los casos, trasladar estos trabajos de larga duración a momentos de poco uso aumenta el rendimiento de las cargas de trabajo de creación de informes o análisis. + Existen vistas que proporcionan información relacionada con STV\$1INFLIGHT. Entre ellas se incluye [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), que captura el texto de consulta de los comandos SQL, y [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md), que une STV\$1INFLIGHT a STL\$1QUERYTEXT. También puede utilizar [STV\$1RECENTS](r_STV_RECENTS.md) con STV\$1INFLIGHT para la solución de problemas. Por ejemplo, STV\$1RECENTS puede indicar si determinadas consultas se encuentran en estado *En ejecución* o *Terminado*. La combinación de esta información con los resultados de STV\$1INFLIGHT puede darle más información sobre las propiedades de una consulta y el impacto en los recursos de computación. También puede monitorear las consultas en ejecución mediante la consola de Amazon Redshift. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_INFLIGHT.html) ## Consultas de ejemplo Consultas de ejemplo Para ver todas las consultas activas que se están ejecutando actualmente en la base de datos, escriba la siguiente consulta: ``` select * from stv_inflight; ``` En el siguiente ejemplo de salida, se muestra dos consultas que se están ejecutando actualmente, incluida la misma consulta STV\$1INFLIGHT y una consulta que se ejecutó desde un script denominado `avgwait.sql`: ``` select slice, query, trim(label) querylabel, pid, starttime, substring(text,1,20) querytext from stv_inflight; slice|query|querylabel | pid | starttime | querytext -----+-----+-----------+-----+--------------------------+-------------------- 1011 | 21 | | 646 |2012-01-26 13:23:15.645503|select slice, query, 1011 | 20 |avgwait.sql| 499 |2012-01-26 13:23:14.159912|select avg(datediff( (2 rows) ``` La siguiente consulta selecciona varias columnas, como concurrency\$1scaling\$1status. Esta columna indica si las consultas se están enviando al clúster de escalado de simultaneidad. Si el valor es `1` para algunos resultados, es una indicación de que se están utilizando recursos de computación con escalado de simultaneidad. Para obtener más información, consulte [Escalado de simultaneidad](concurrency-scaling.md). ``` select userid, query, pid, starttime, text, suspended, concurrency_scaling_status from STV_INFLIGHT; ``` La salida de ejemplo muestra el envío de una consulta al clúster de escalado de simultaneidad. ``` query | pid | starttime | text | suspended | concurrency_scaling_status --------+---------+----------------------------|------------------------|---------------|------------------------------- 1234567 | 123456 | 2012-01-26 13:23:15.645503 | select userid, query... 0 1 2345678 | 234567 | 2012-01-26 13:23:14.159912 | select avg(datediff(... 0 0 (2 rows) ``` Para obtener más consejos sobre la resolución de problemas de rendimiento de las consultas, consulte [Solución de problemas de consultas](queries-troubleshooting.md). # STV\$1LOAD\$1STATE STV\$1LOAD\$1STATE Utilice la tabla STV\$1LOAD\$1STATE para encontrar información acerca del estado actual de las instrucciones COPY en curso. El comando COPY actualiza esta tabla cada vez que se carga un millón de registros. Todos los usuarios pueden ver STV\$1LOAD\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_LOAD_STATE.html) ## Consulta de ejemplo Consulta de ejemplo Para ver el progreso de cada sector de un comando COPY, escriba la siguiente consulta. En este ejemplo, se usa la función PG\$1LAST\$1COPY\$1ID() para recuperar información para el último comando COPY. ``` select slice , bytes_loaded, bytes_to_load , pct_complete from stv_load_state where query = pg_last_copy_id(); slice | bytes_loaded | bytes_to_load | pct_complete -------+--------------+---------------+-------------- 2 | 0 | 0 | 0 3 | 12840898 | 39104640 | 32 (2 rows) ``` # STV\$1LOCKS STV\$1LOCKS Utilice la tabla STV\$1LOCKS para ver todas las actualizaciones de las tablas en la base de datos. Amazon Redshift bloquea tablas para evitar que dos usuarios actualicen la misma tabla al mismo tiempo. Mientras la tabla STV\$1LOCKS muestra todas las actualizaciones actuales de las tablas, consulte la tabla [STL\$1TR\$1CONFLICT](r_STL_TR_CONFLICT.md) para ver un registro de los conflictos de bloqueos. Utilice la vista [SVV\$1TRANSACTIONS](r_SVV_TRANSACTIONS.md) para identificar las transacciones abiertas y bloquear los problemas de contención. Solo los superusuarios pueden ver STV\$1LOCKS. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_LOCKS.html) ## Consulta de ejemplo Consulta de ejemplo Para ver todos los bloqueos que se están realizando en las transacciones actuales, escriba el siguiente comando: ``` select table_id, last_update, lock_owner, lock_owner_pid from stv_locks; ``` Esta consulta devuelve el siguiente ejemplo de salida, en el que se muestran tres bloqueos actualmente activos: ``` table_id | last_update | lock_owner | lock_owner_pid ----------+----------------------------+------------+---------------- 100004 | 2008-12-23 10:08:48.882319 | 1043 | 5656 100003 | 2008-12-23 10:08:48.779543 | 1043 | 5656 100140 | 2008-12-23 10:08:48.021576 | 1043 | 5656 (3 rows) ``` # STV\$1ML\$1MODEL\$1INFO STV\$1ML\$1MODEL\$1INFO Información acerca del estado actual del modelo de machine learning. Todos los usuarios pueden ver STV\$1ML\$1MODEL\$1INFO. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_ML_MODEL_INFO.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el estado actual de los modelos de machine learning. ``` SELECT schema_name, model_name, model_state FROM stv_ml_model_info; schema_name | model_name | model_state -------------+------------------------------+-------------------------------------- public | customer_churn_auto_model | Train Model On SageMaker In Progress public | customer_churn_xgboost_model | Model is Ready (2 row) ``` # STV\$1MV\$1DEPS STV\$1MV\$1DEPS En la tabla STV\$1MV\$1DEPS, se muestran las dependencias de vistas materializadas con respecto a otras vistas materializadas de Amazon Redshift. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). Todos los usuarios pueden ver STV\$1MV\$1DEPS. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver las vistas materializadas que residen en los esquemas a los que tienen acceso. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas del sistema](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_MV_DEPS.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve una fila de salida que indica que la vista materializada `mv_over_foo` utiliza la vista materializada `mv_foo` en su definición como una dependencia. ``` CREATE SCHEMA test_ivm_setup; CREATE TABLE test_ivm_setup.foo(a INT); CREATE MATERIALIZED VIEW test_ivm_setup.mv_foo AS SELECT * FROM test_ivm_setup.foo; CREATE MATERIALIZED VIEW test_ivm_setup.mv_over_foo AS SELECT * FROM test_ivm_setup.mv_foo; SELECT * FROM stv_mv_deps; db_name | schema | name | ref_schema | ref_name | ref_database_name ---------+-----------------+-------------+----------------+----------+------------------ dev | test_ivm_setup | mv_over_foo | test_ivm_setup | mv_foo | dev ``` # STV\$1MV\$1INFO STV\$1MV\$1INFO La tabla STV\$1MV\$1INFO contiene una fila para cada vista materializada, si los datos están o no obsoletos, e información de estado. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). Todos los usuarios pueden ver STV\$1MV\$1INFO. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver las vistas materializadas que residen en los esquemas a los que tienen acceso. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas del sistema](https://docs.aws.amazon.com/redshift/latest/dg/cm_chap_system-tables.html#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_MV_INFO.html) ## Consulta de ejemplo Consulta de ejemplo Para ver el estado de todas las vistas materializadas, ejecute la siguiente consulta. ``` select * from stv_mv_info; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` db_name | schema | name | updated_upto_xid | is_stale | owner_user_name | state | autorefresh | autorewrite ---------+--------------------+---------+------------------+----------+-----------------+-------+-------------+------------ dev | test_ivm_setup | mv | 1031 | f | catch-22 | 1 | 1 | 0 dev | test_ivm_setup | old_mv | 988 | t | lotr | 1 | 0 | 1 ``` # STV\$1NODE\$1STORAGE\$1CAPACITY STV\$1NODE\$1STORAGE\$1CAPACITY En la tabla STV\$1NODE\$1STORAGE\$1CAPACITY, se muestran los detalles de la capacidad total de almacenamiento y la capacidad total utilizada de cada nodo de un clúster. Contiene una fila para cada nodo. Solo los superusuarios pueden ver STV\$1NODE\$1STORAGE\$1CAPACITY. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_NODE_STORAGE_CAPACITY.html) ## Consultas de ejemplo Consultas de ejemplo **nota** Los resultados de los siguientes ejemplos varían en función de las especificaciones de los nodos de su clúster. Agregue la columna `capacity` a su SQL SELECT para recuperar la capacidad del clúster. La siguiente consulta devuelve el espacio utilizado y la capacidad total en bloques de disco de 1 MB. Este ejemplo se ejecutó en un clúster de dos nodos dc2.8xlarge. ``` select node, used from stv_node_storage_capacity order by node; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` node | used ------+------- 0 | 30597 1 | 27089 ``` La siguiente consulta devuelve el espacio utilizado y la capacidad total en bloques de disco de 1 MB. Este ejemplo se ejecutó en un clúster de dos nodos ra3.16xlarge. ``` select node, used from stv_node_storage_capacity order by node; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` node | used ------+------- 0 | 30591 1 | 27103 ``` # STV\$1PARTITIONS STV\$1PARTITIONS Utilice la tabla STV\$1PARTITIONS para conocer el rendimiento de la velocidad del disco y la utilización del disco para Amazon Redshift. STV\$1PARTITIONS contiene una fila por nodo y por volumen lógico de disco. Solo los superusuarios pueden ver STV\$1PARTITIONS. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_PARTITIONS.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el espacio de disco utilizado y la capacidad, en bloques de disco de 1 MB, y calcula la utilización del disco como un porcentaje del espacio de disco en bruto. El espacio de disco en bruto incluye el espacio que reserva Amazon Redshift para uso interno, por lo que supera su capacidad nominal, la cual corresponde a la cantidad de espacio de disco disponible para el usuario. La métrica **Porcentaje de espacio de disco utilizado** de la pestaña **Performance** (Rendimiento) de la consola de administración de Amazon Redshift indica el porcentaje de la capacidad nominal del disco que utiliza el clúster. Le recomendamos que monitoree la métrica **Porcentaje de espacio de disco utilizado** para mantener el uso dentro de la capacidad nominal del disco del clúster. **importante** Le recomendamos encarecidamente que no supere la capacidad nominal del disco de su clúster. Si bien puede ser técnicamente posible bajo ciertas circunstancias, superar la capacidad nominal de su disco disminuye la tolerancia a errores de su clúster y aumenta el riesgo de perder datos. Este ejemplo se ejecutó en un clúster de dos nodos con seis particiones lógicas del disco por cada nodo. El espacio se utiliza de manera muy uniforme en todos los discos, donde se usa, aproximadamente, el 25% de cada disco. ``` select owner, host, diskno, used, capacity, (used-tossed)/capacity::numeric *100 as pctused from stv_partitions order by owner; owner | host | diskno | used | capacity | pctused -------+------+--------+--------+----------+--------- 0 | 0 | 0 | 236480 | 949954 | 24.9 0 | 0 | 1 | 236420 | 949954 | 24.9 0 | 0 | 2 | 236440 | 949954 | 24.9 0 | 1 | 2 | 235150 | 949954 | 24.8 0 | 1 | 1 | 237100 | 949954 | 25.0 0 | 1 | 0 | 237090 | 949954 | 25.0 1 | 1 | 0 | 236310 | 949954 | 24.9 1 | 1 | 1 | 236300 | 949954 | 24.9 1 | 1 | 2 | 236320 | 949954 | 24.9 1 | 0 | 2 | 237910 | 949954 | 25.0 1 | 0 | 1 | 235640 | 949954 | 24.8 1 | 0 | 0 | 235380 | 949954 | 24.8 (12 rows) ``` # STV\$1QUERY\$1METRICS STV\$1QUERY\$1METRICS Tiene 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 activas que se están ejecutando en colas de consultas (clases de servicios) definidas por el usuario. Para ver las métricas de las consultas que se han completado, consulte la tabla de sistema [STL\$1QUERY\$1METRICS](r_STL_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 consultas que se ejecutan en menos de 1 segundo no se registren. STV\$1QUERY\$1METRICS hace un seguimiento y agrega métricas en el de 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. STV\$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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_QUERY_METRICS.html) ## Tipos de pasos Tipos de pasos En la siguiente tabla, se muestran los tipos de pasos relevantes para usuarios de bases de datos. En la tabla no se muestran los tipos de pasos que son solo para uso interno. Si el tipo de paso es -1, la métrica no se informa a nivel paso. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_QUERY_METRICS.html) ## Consulta de ejemplo Consulta de ejemplo Para encontrar consultas activas 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 stv_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 stv_query_metrics where step_type = 15 and rows > 1000000 order by rows; query | rows ------+----------- 25775 | 1580225854 ``` 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 stv_query_metrics where segment = -1 and run_time > 60000000 and cpu_time < 10000000; query | run_time_seconds ------+----------------- 25775 | 114 ``` # STV\$1RECENTS STV\$1RECENTS Utilice la tabla STV\$1RECENTS para obtener información acerca de las consultas que están activas actualmente y las que se han ejecutado recientemente en relación con una base de datos. Todos los usuarios pueden ver STV\$1RECENTS. 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. ## Solución de problemas con STV\$1RECENTS Solución de problemas con STV\$1RECENTS STV\$1RECENTS es útil, en concreto, para determinar si una consulta o una colección de consultas se está ejecutando en ese momento o se ha realizado. También muestra el tiempo que se ha estado ejecutando una consulta. Esto es útil para hacerse una idea de qué consultas son de larga duración. Puede unir STV\$1RECENTS a otras vistas del sistema, como [STV\$1INFLIGHT](r_STV_INFLIGHT.md), para recopilar metadatos adicionales sobre las consultas en ejecución. (Hay un ejemplo que muestra cómo hacerlo en la sección de consultas de ejemplo). También puede utilizar los registros devueltos desde esta vista junto con las características de monitoreo de la consola de Amazon Redshift para solucionar problemas en tiempo real. Las vistas del sistema que complementan STV\$1RECENTS incluyen [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md), que recupera el texto de consulta para los comandos SQL, y [SVV\$1QUERY\$1INFLIGHT](r_SVV_QUERY_INFLIGHT.md), que une STV\$1INFLIGHT a STL\$1QUERYTEXT. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_RECENTS.html) ## Consultas de ejemplo Consultas de ejemplo Para determinar cuáles son las consultas que se están ejecutando actualmente en la base de datos, ejecute la siguiente consulta: ``` select user_name, db_name, pid, query from stv_recents where status = 'Running'; ``` En el siguiente ejemplo de salida, se muestra que hay una única consulta en ejecución en la base de datos TICKIT: ``` user_name | db_name | pid | query ----------+---------+---------+------------- dwuser | tickit | 19996 |select venuename, venueseats from venue where venueseats > 50000 order by venueseats desc; ``` En el siguiente ejemplo, se devuelve una lista de consultas (en caso de haber alguna) que se están ejecutando o que están esperando en una cola para ejecutarse: ``` select * from stv_recents where status<>'Done'; status | starttime | duration |user_name|db_name| query | pid -------+---------------------+----------+---------+-------+-----------+------ Running| 2010-04-21 16:11... | 281566454| dwuser |tickit | select ...| 23347 ``` Esta consulta no devuelve resultados a menos que esté ejecutando una serie de consultas simultáneas y algunas estén en una cola. En el siguiente ejemplo, se amplía el ejemplo anterior. En este caso, las consultas que están realmente "en tránsito" (ejecutándose, no esperando) no están incluidas en el resultado: ``` select * from stv_recents where status<>'Done' and pid not in (select pid from stv_inflight); ... ``` Para obtener más consejos sobre la resolución de problemas de rendimiento de las consultas, consulte [Solución de problemas de consultas](queries-troubleshooting.md). # STV\$1SESSIONS STV\$1SESSIONS Utilice la tabla STV\$1SESSIONS para ver información acerca de las sesiones de usuario activas para Amazon Redshift. Para ver el historial de sesiones, utilice la tabla [STL\$1SESSIONS](r_STL_SESSIONS.md), en lugar de STV\$1SESSIONS. STV\$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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_SESSIONS.html) ## Consultas de ejemplo Consultas de ejemplo Para verificar rápidamente si hay algún otro usuario en este momento con una sesión abierta en Amazon Redshift, escriba la siguiente consulta: ``` select count(*) from stv_sessions; ``` Si el resultado es mayor que uno, hay al menos un usuario más en este momento con una sesión abierta en la base de datos. Para ver todas las sesiones activas de Amazon Redshift, escriba la siguiente consulta: ``` select * from stv_sessions; ``` El siguiente resultado muestra cuatro sesiones activas actualmente en Amazon Redshift: ``` starttime | process |user_name | db_name | timeout_sec -------------------------+---------+----------------------------+----------------------------+------------- 2018-08-06 08:44:07.50 | 13779 | IAMA:aws_admin:admin_grp | dev | 0 2008-08-06 08:54:20.50 | 19829 | dwuser | dev | 120 2008-08-06 08:56:34.50 | 20279 | dwuser | dev | 120 2008-08-06 08:55:00.50 | 19996 | dwuser | tickit | 0 (3 rows) ``` En nombre de usuario con el prefijo IAMA indica que el usuario inició una sesión con el inicio de sesión único federado. Para obtener más información, consulte [Uso de la autenticación de IAM para generar credenciales de usuario de base de datos](https://docs.aws.amazon.com/redshift/latest/mgmt/generating-user-credentials.html). # STV\$1SLICES STV\$1SLICES Utilice la tabla STV\$1SLICES para ver el mapeo actual de un sector a un nodo. La información de STV\$1SLICES se utiliza, principalmente, para investigaciones. Todos los usuarios pueden ver STV\$1SLICES. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_SLICES.html) ## Consulta de ejemplo Consulta de ejemplo Para ver qué nodos del clúster está administrando cada sector, escriba la siguiente consulta: ``` select node, slice from stv_slices; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` node | slice ------+------- 0 | 2 0 | 3 0 | 1 0 | 0 (4 rows) ``` # STV\$1STARTUP\$1RECOVERY\$1STATE STV\$1STARTUP\$1RECOVERY\$1STATE Registra el estado de las tablas que están bloqueadas temporalmente durante las operaciones de reinicio del clúster. Amazon Redshift bloquea de manera temporal las tablas mientras estas se procesan para resolver transacciones obsoletas después de que se reinicia un clúster. STV\$1STARTUP\$1RECOVERY\$1STATE es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_STARTUP_RECOVERY_STATE.html) ## Consultas de ejemplo Consultas de ejemplo Para monitorear qué tablas están bloqueadas temporalmente, ejecute la siguiente consulta después de que se reinicie un clúster. ``` select * from STV_STARTUP_RECOVERY_STATE; db_id | tbl_id | table_name --------+--------+------------ 100044 | 100058 | lineorder 100044 | 100068 | part 100044 | 100072 | customer 100044 | 100192 | supplier (4 rows) ``` # STV\$1TBL\$1PERM STV\$1TBL\$1PERM La tabla STV\$1TBL\$1PERM tiene información acerca de las tablas permanentes en Amazon Redshift, incluidas las tablas temporales creadas por un usuario para esta sesión. STV\$1TBL\$1PERM tiene información de todas las tablas en todas las bases de datos. Esta tabla se diferencia de [STV\$1TBL\$1TRANS](r_STV_TBL_TRANS.md), la cual tiene información relacionada con las tablas transitorias de bases de datos que el sistema crea durante el procesamiento de consultas. Solo los superusuarios pueden ver STV\$1TBL\$1PERM. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_TBL_PERM.html) ## Consultas de ejemplo Consultas de ejemplo La siguiente consulta devuelve una lista de diferentes ID y nombres de tablas: ``` select distinct id, name from stv_tbl_perm order by name; id | name --------+------------------------- 100571 | category 100575 | date 100580 | event 100596 | listing 100003 | padb_config_harvest 100612 | sales ... ``` Otras tablas de sistema usan ID de tablas, por lo que puede resultar muy útil saber qué ID de tabla corresponde a una tabla determinada. En este ejemplo, se utiliza el comando SELECT DISTINCT para eliminar duplicados (las tablas se distribuyen en diferente sectores). Para determinar la cantidad de bloques que utiliza cada columna de la tabla VENUE, escriba la siguiente consulta: ``` select col, count(*) from stv_blocklist, stv_tbl_perm where stv_blocklist.tbl = stv_tbl_perm.id and stv_blocklist.slice = stv_tbl_perm.slice and stv_tbl_perm.name = 'venue' group by col order by col; col | count -----+------- 0 | 8 1 | 8 2 | 8 3 | 8 4 | 8 5 | 8 6 | 8 7 | 8 (8 rows) ``` ## Notas de uso Notas de uso La columna ROWS incluye los recuentos de las filas eliminadas que no se limpiaron (o que se limpiaron, pero con la opción SORT ONLY). Por lo tanto, es posible que el resultado de SUM de la columna ROWS en la tabla STV\$1TBL\$1PERM no coincida con el resultado de COUNT(\$1) cuando consulta directamente una tabla determinada. Por ejemplo, si se eliminan 2 filas de VENUE, el resultado de COUNT(\$1) es 200, pero el resultado de SUM(ROWS) sigue siendo 202: ``` delete from venue where venueid in (1,2); select count(*) from venue; count ------- 200 (1 row) select trim(name) tablename, sum(rows) from stv_tbl_perm where name='venue' group by name; tablename | sum -----------+----- venue | 202 (1 row) ``` Para sincronizar los datos en STV\$1TBL\$1PERM, ejecute una limpieza completa en la tabla VENUE. ``` vacuum venue; select trim(name) tablename, sum(rows) from stv_tbl_perm where name='venue' group by name; tablename | sum -----------+----- venue | 200 (1 row) ``` # STV\$1TBL\$1TRANS STV\$1TBL\$1TRANS Utilice la tabla STV\$1TBL\$1TRANS para encontrar información acerca de las tablas transitorias de las bases de datos que están actualmente en la memoria. Las tablas transitorias son, por lo general, conjuntos de filas temporales que se usan como resultados intermedios mientras se ejecuta una consulta. STV\$1TBL\$1TRANS se diferencia de [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md) debido a que STV\$1TBL\$1PERM tiene información acerca de las tablas permanentes de las bases de datos. Solo los superusuarios pueden ver STV\$1TBL\$1TRANS. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_TBL_TRANS.html) ## Consultas de ejemplo Consultas de ejemplo Para ver información acerca de las tablas transitorias para una consulta con un ID de consulta de 90, escriba el siguiente comando: ``` select slice, id, rows, size, query_id, ref_cnt from stv_tbl_trans where query_id = 90; ``` Esta consulta devuelve información acerca de las tablas transitorias para una consulta 90, tal como se muestra en el siguiente ejemplo de salida: ``` slice | id | rows | size | query_ | ref_ | from_ | prep_ | | | | id | cnt | suspended | swap ------+----+------+------+--------+------+-----------+------- 1013 | 95 | 0 | 0 | 90 | 4 | 0 | 0 7 | 96 | 0 | 0 | 90 | 4 | 0 | 0 10 | 96 | 0 | 0 | 90 | 4 | 0 | 0 17 | 96 | 0 | 0 | 90 | 4 | 0 | 0 14 | 96 | 0 | 0 | 90 | 4 | 0 | 0 3 | 96 | 0 | 0 | 90 | 4 | 0 | 0 1013 | 99 | 0 | 0 | 90 | 4 | 0 | 0 9 | 96 | 0 | 0 | 90 | 4 | 0 | 0 5 | 96 | 0 | 0 | 90 | 4 | 0 | 0 19 | 96 | 0 | 0 | 90 | 4 | 0 | 0 2 | 96 | 0 | 0 | 90 | 4 | 0 | 0 1013 | 98 | 0 | 0 | 90 | 4 | 0 | 0 13 | 96 | 0 | 0 | 90 | 4 | 0 | 0 1 | 96 | 0 | 0 | 90 | 4 | 0 | 0 1013 | 96 | 0 | 0 | 90 | 4 | 0 | 0 6 | 96 | 0 | 0 | 90 | 4 | 0 | 0 11 | 96 | 0 | 0 | 90 | 4 | 0 | 0 15 | 96 | 0 | 0 | 90 | 4 | 0 | 0 18 | 96 | 0 | 0 | 90 | 4 | 0 | 0 ``` En este ejemplo, puede ver que los datos de la consulta involucran a las tablas 95, 96 y 98. Como no hay ningún byte asignado a esta tabla, esta consulta puede ejecutarse en la memoria. # STV\$1WLM\$1CLASSIFICATION\$1CONFIG STV\$1WLM\$1CLASSIFICATION\$1CONFIG Tiene las reglas actuales de clasificación para WLM. Solo los superusuarios pueden ver STV\$1WLM\$1CLASSIFICATION\$1CONFIG. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_CLASSIFICATION_CONFIG.html) ## Consulta de ejemplo Consulta de ejemplo ``` select * from STV_WLM_CLASSIFICATION_CONFIG; id | condition | action_seq | action | action_service_class ---+---------------------------------------------+------------+--------+--------------------- 1 | (system user) and (query group: health) | 0 | assign | 1 2 | (system user) and (query group: metrics) | 0 | assign | 2 3 | (system user) and (query group: cmstats) | 0 | assign | 3 4 | (system user) | 0 | assign | 4 5 | (super user) and (query group: superuser) | 0 | assign | 5 6 | (query group: querygroup1) | 0 | assign | 6 7 | (user group: usergroup1) | 0 | assign | 6 8 | (user group: usergroup2) | 0 | assign | 7 9 | (query group: querygroup3) | 0 | assign | 8 10 | (query group: querygroup4) | 0 | assign | 9 11 | (user group: usergroup4) | 0 | assign | 9 12 | (query group: querygroup*) | 0 | assign | 10 13 | (user group: usergroup*) | 0 | assign | 10 14 | (querytype: any) | 0 | assign | 11 (4 rows) ``` # STV\$1WLM\$1QMR\$1CONFIG STV\$1WLM\$1QMR\$1CONFIG Registra la configuración para las Query Monitoring Rules (QMR, Reglas de monitorización de consultas) de WLM. Para obtener más información, consulte [Reglas de monitoreo de consultas de WLM](cm-c-wlm-query-monitoring-rules.md). Solo los superusuarios pueden ver STV\$1WLM\$1QMR\$1CONFIG. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_QMR_CONFIG.html) ## Consulta de ejemplo Consulta de ejemplo Para ver las definiciones de las reglas de QMR para todas las clases de servicio mayores que 5 (se incluyen colas definidas por el usuario), ejecute la siguiente consulta. 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). ``` Select * from stv_wlm_qmr_config where service_class > 5 order by service_class; ``` # STV\$1WLM\$1QUERY\$1QUEUE\$1STATE STV\$1WLM\$1QUERY\$1QUEUE\$1STATE Registra el estado actual de las colas de consultas para las clases de servicios. Todos los usuarios pueden ver STV\$1WLM\$1QUERY\$1QUEUE\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_QUERY_QUEUE_STATE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra las consultas en la cola para las clases de servicio mayores que 4. ``` select * from stv_wlm_query_queue_state where service_class > 4 order by service_class; ``` Esta consulta devuelve el siguiente ejemplo de salida. ``` service_class | position | task | query | slot_count | start_time | queue_time ---------------+----------+------+-------+------------+----------------------------+------------ 5 | 0 | 455 | 476 | 5 | 2010-10-06 13:18:24.065838 | 20937257 6 | 1 | 456 | 478 | 5 | 2010-10-06 13:18:26.652906 | 18350191 (2 rows) ``` # STV\$1WLM\$1QUERY\$1STATE STV\$1WLM\$1QUERY\$1STATE Registra el estado actual de las consultas de las que WLM hace un seguimiento. Todos los usuarios pueden ver STV\$1WLM\$1QUERY\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_QUERY_STATE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra todas las consultas que se están ejecutando actualmente en 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). ``` select xid, query, trim(state) as state, queue_time, exec_time from stv_wlm_query_state where service_class > 4; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` xid | query | state | queue_time | exec_time -------+-------+---------+------------+----------- 100813 | 25942 | Running | 0 | 1369029 100074 | 25775 | Running | 0 | 2221589242 ``` # STV\$1WLM\$1QUERY\$1TASK\$1STATE STV\$1WLM\$1QUERY\$1TASK\$1STATE Tiene el estado actual de las tareas de consultas de las clases de servicios. Todos los usuarios pueden ver STV\$1WLM\$1QUERY\$1TASK\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_QUERY_TASK_STATE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el estado actual de las consultas en 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). ``` select * from stv_wlm_query_task_state where service_class > 4; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` service_class | task | query | start_time | exec_time --------------+------+-------+----------------------------+----------- 5 | 466 | 491 | 2010-10-06 13:29:23.063787 | 357618748 (1 row) ``` # STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG Registra las configuraciones de las clases de servicios para WLM. Solo los superusuarios pueden ver STV\$1WLM\$1SERVICE\$1CLASS\$1CONFIG. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_CONFIG.html) ## Consulta de ejemplo Consulta de ejemplo La primera clase de servicio definida por el usuario es la clase de servicio 6, que se denominada clase de servicio n. ° 1. La siguiente consulta muestra 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). ``` select rtrim(name) as name, num_query_tasks as slots, query_working_mem as mem, max_execution_time as max_time, user_group_wild_card as user_wildcard, query_group_wild_card as query_wildcard from stv_wlm_service_class_config where service_class > 4; name | slots | mem | max_time | user_wildcard | query_wildcard -----------------------------+-------+-----+----------+---------------+--------------- Service class for super user | 1 | 535 | 0 | false | false Queue 1 | 5 | 125 | 0 | false | false Queue 2 | 5 | 125 | 0 | false | false Queue 3 | 5 | 125 | 0 | false | false Queue 4 | 5 | 627 | 0 | false | false Queue 5 | 5 | 125 | 0 | true | true Default queue | 5 | 125 | 0 | false | false ``` La siguiente consulta muestra el estado de una transición dinámica de WLM. Mientras la transición está en proceso, `num_query_tasks` y `target_query_working_mem` se actualizan hasta que se equiparan con los valores de destino. Para obtener más información, consulte [Propiedades de configuración dinámicas y estáticas de WLM](cm-c-wlm-dynamic-properties.md). ``` select rtrim(name) as name, num_query_tasks as slots, target_num_query_tasks as target_slots, query_working_mem as memory, target_query_working_mem as target_memory from stv_wlm_service_class_config where num_query_tasks > target_num_query_tasks or query_working_mem > target_query_working_mem and service_class > 5; name | slots | target_slots | memory | target_mem ------------------+-------+--------------+--------+------------ Queue 3 | 5 | 15 | 125 | 375 Queue 5 | 10 | 5 | 250 | 125 (2 rows) ``` # STV\$1WLM\$1SERVICE\$1CLASS\$1STATE STV\$1WLM\$1SERVICE\$1CLASS\$1STATE Tiene el estado actual de las clases de servicios. Solo los superusuarios pueden ver STV\$1WLM\$1SERVICE\$1CLASS\$1STATE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_WLM_SERVICE_CLASS_STATE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el estado de las clases de servicio mayores que 5. 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). ``` select service_class, num_executing_queries, num_executed_queries from stv_wlm_service_class_state where service_class > 5 order by service_class; ``` ``` service_class | num_executing_queries | num_executed_queries ---------------+-----------------------+---------------------- 6 | 1 | 222 7 | 0 | 135 8 | 1 | 39 (3 rows) ``` # STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE Utilice STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE para monitorear el progreso de la migración de cada tabla durante un cambio de tamaño clásico. Esto es aplicable específicamente cuando el tipo de nodo de destino es RA3. Para obtener más información sobre el cambio de tamaño clásico en los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster). Solo los superusuarios pueden ver STV\$1XRESTORE\$1ALTER\$1QUEUE\$1STATE. 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\$1RESTORE\$1STATE](SYS_RESTORE_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_STV_XRESTORE_ALTER_QUEUE_STATE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el número de tablas de una base de datos que están esperando a que se cambien de tamaño, que se están cambiando de tamaño en ese momento y que se han terminado de cambiar de tamaño. ``` select db_id, status, count(*) from stv_xrestore_alter_queue_state group by 1,2 order by 3 desc db_id | status | count -------+------------+------ 694325 | Waiting | 323 694325 | Finished | 60 694325 | Applying | 1 ``` # Vistas de SVCS para clústeres de escalado principales y de simultaneidad Vistas de SVCS para clústeres de escalado principales y de simultaneidad Las vistas del sistema SVCS con el prefijo SVCS proporcionan información sobre las consultas tanto de los clústeres principales como de los clústeres de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. **Topics** + [ # SVCS\$1ALERT\$1EVENT\$1LOG ](r_SVCS_ALERT_EVENT_LOG.md) + [ # SVCS\$1COMPILE ](r_SVCS_COMPILE.md) + [ # SVCS\$1CONCURRENCY\$1SCALING\$1USAGE ](r_SVCS_CONCURRENCY_SCALING_USAGE.md) + [ # SVCS\$1EXPLAIN ](r_SVCS_EXPLAIN.md) + [ # SVCS\$1PLAN\$1INFO ](r_SVCS_PLAN_INFO.md) + [ # SVCS\$1QUERY\$1SUMMARY ](r_SVCS_QUERY_SUMMARY.md) + [ # SVCS\$1S3LIST ](r_SVCS_S3LIST.md) + [ # SVCS\$1S3LOG ](r_SVCS_S3LOG.md) + [ # SVCS\$1S3PARTITION\$1SUMMARY ](r_SVCS_S3PARTITION_SUMMARY.md) + [ # SVCS\$1S3QUERY\$1SUMMARY ](r_SVCS_S3QUERY_SUMMARY.md) + [ # SVCS\$1STREAM\$1SEGS ](r_SVCS_STREAM_SEGS.md) + [ # SVCS\$1UNLOAD\$1LOG ](r_SVCS_UNLOAD_LOG.md) # SVCS\$1ALERT\$1EVENT\$1LOG SVCS\$1ALERT\$1EVENT\$1LOG Registra una alerta cuando el optimizador de consultas identifica condiciones que podrían indicar problemas de rendimiento. Esta vista se obtiene de la tabla del sistema STL\$1ALERT\$1EVENT\$1LOG, pero no muestra el sector de las consultas ejecutadas en un clúster de escalado de simultaneidad. Utilice la tabla SVCS\$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). **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1ALERT\$1EVENT\$1LOG. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_ALERT_EVENT_LOG.html) ## Notas de uso Puede utilizar SVCS\$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. SVCS\$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 escaneadas se obtienen del valor de `rows_pre_user_filter `y las filas devueltas, del valor de las filas de la tabla 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 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 svcs_alert_event_log order by query; query | event | solution | event_time -------+-------------------------------+------------------------------+--------------------- 6567 | Missing query planner statist | Run the ANALYZE command | 2014-01-03 18:20:58 7450 | Scanned a large number of del | Run the VACUUM command to rec| 2014-01-03 21:19:31 8406 | Nested Loop Join in the query | Review the join predicates to| 2014-01-04 00:34:22 29512 | Very selective query filter:r | Review the choice of sort key| 2014-01-06 22:00:00 (4 rows) ``` # SVCS\$1COMPILE SVCS\$1COMPILE Registra el tiempo de compilación y la ubicación de cada segmento de consulta, incluidas las consultas ejecutadas en un clúster de escalado y las ejecutadas en el clúster principal. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. SVCS\$1COMPILE 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). Para obtener información sobre SCL\$1COMPILE, consulte [SVL\$1COMPILE](r_SVL_COMPILE.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_COMPILE.html) ## Consultas de ejemplo Consultas de ejemplo En este ejemplo, las consultas 35878 y 35879 ejecutaron la misma instrucción SQL. La columna de compilación para la consulta 35878 muestra `1` para cuatro segmentos de consulta, lo que indica que esos segmentos se compilaron. La consulta 35879 muestra `0` en la columna de compilación para cada segmento, lo que indica que esos segmentos no se volvieron a compilar. ``` select userid, xid, pid, query, segment, locus, datediff(ms, starttime, endtime) as duration, compile from svcs_compile where query = 35878 or query = 35879 order by query, segment; userid | xid | pid | query | segment | locus | duration | compile --------+--------+-------+-------+---------+-------+----------+--------- 100 | 112780 | 23028 | 35878 | 0 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 1 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 2 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 3 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 4 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 5 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 6 | 1 | 1380 | 1 100 | 112780 | 23028 | 35878 | 7 | 1 | 1085 | 1 100 | 112780 | 23028 | 35878 | 8 | 1 | 1197 | 1 100 | 112780 | 23028 | 35878 | 9 | 2 | 905 | 1 100 | 112782 | 23028 | 35879 | 0 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 1 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 2 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 3 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 4 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 5 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 6 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 7 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 8 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 9 | 2 | 0 | 0 (20 rows) ``` # SVCS\$1CONCURRENCY\$1SCALING\$1USAGE SVCS\$1CONCURRENCY\$1SCALING\$1USAGE Registra los periodos de uso del escalado de simultaneidad. Cada periodo de uso es una duración consecutiva en la que un clúster de escalado de simultaneidad procesa consultas. SVCS\$1CONCURRENCY\$1SCALING\$1USAGE Los superusuarios pueden ver esta tabla. El superusuario de la base de datos puede elegir hacerla visible a todos los usuarios. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_CONCURRENCY_SCALING_USAGE.html) ## Consultas de ejemplo Consultas de ejemplo Para ver la duración de uso en segundos para un periodo específico, escriba la siguiente consulta: ``` select * from svcs_concurrency_scaling_usage order by start_time; start_time | end_time | queries | usage_in_seconds ----------------------------+----------------------------+---------+------------------ 2019-02-14 18:43:53.01063 | 2019-02-14 19:16:49.781649 | 48 | 1977 ``` # SVCS\$1EXPLAIN SVCS\$1EXPLAIN Muestra el plan EXPLAIN de una consulta que se ha enviado para ejecutarse. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. SVCS\$1EXPLAIN es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_EXPLAIN.html) ## Consultas de ejemplo 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 SVCS\$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 svcs_explain where query=10 order by 1,2; query| nodeid |parentid| substring | substring -----+--------+--------+--------------------------------+------------------- 10 | 1 | 0 |XN Aggregate (cost=6717.61..6 | 10 | 2 | 1 | -> XN Merge Join DS_DIST_NO| Merge Cond:("outer" 10 | 3 | 2 | -> XN Seq Scan on lis | 10 | 4 | 2 | -> XN Seq Scan on sal | (4 rows) ``` 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 tabla de sistema devolverá los nodos del plan que se realizaron. 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 svcs_explain where query=15 order by 1, 2 desc; query|nodeid|parentid| substring -----+------+--------+-------------------------------------------------------- 15 | 8 | 7 | -> XN Seq Scan on eve 15 | 7 | 5 | -> XN Hash(cost=87.98..87.9 15 | 6 | 5 | -> XN Seq Scan on sales(cos 15 | 5 | 4 | -> XN Hash Join DS_DIST_OUTER(cos 15 | 4 | 3 | -> XN HashAggregate(cost=862286577.07.. 15 | 3 | 2 | -> XN Sort(cost=1000862287175.47..10008622871 15 | 2 | 1 | -> XN Network(cost=1000862287175.47..1000862287197. 15 | 1 | 0 |XN Merge(cost=1000862287175.47..1000862287197.46 rows=87 (8 rows) ``` 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 svcs_explain where plannode like '%Window%'; query| btrim -----+------------------------------------------------------------------------ 26 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) 27 | -> XN Window(cost=1000985348268.57..1000985351256.98 rows=170 width=33) (2 rows) ``` # SVCS\$1PLAN\$1INFO SVCS\$1PLAN\$1INFO Utilice la tabla SVCS\$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. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. SVCS\$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). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_PLAN_INFO.html) ## Consultas de ejemplo Consultas de ejemplo Los siguientes ejemplos comparan los planes de consulta para una consulta simple SELECT, resultado del uso del comando EXPLAIN y de consultar la tabla SVCS\$1PLAN\$1INFO. ``` explain select * from category; QUERY PLAN ------------------------------------------------------------- XN Seq Scan on category (cost=0.00..0.11 rows=11 width=49) (1 row) select * from category; catid | catgroup | catname | catdesc -------+----------+-----------+-------------------------------------------- 1 | Sports | MLB | Major League Baseball 3 | Sports | NFL | National Football League 5 | Sports | MLS | Major League Soccer ... select * from svcs_plan_info where query=256; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+-------------+-----------+------+------- 256 | 1 | 0 | 1 | 0 | 104 | 0 | 0.11 | 11 | 539 256 | 1 | 0 | 0 | 0 | 104 | 0 | 0.11 | 11 | 539 (2 rows) ``` 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 svcs_plan_info where query=240 order by nodeid desc; query | nodeid | segment | step | locus | plannode | startupcost | totalcost | rows | bytes -------+--------+---------+------+-------+----------+------------------+------------------+------+-------- 240 | 5 | 0 | 0 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 5 | 0 | 1 | 0 | 104 | 0 | 87.98 | 8798 | 149566 240 | 4 | 0 | 2 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 0 | 3 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 0 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 4 | 1 | 1 | 0 | 117 | 0 | 109.975 | 576 | 9792 240 | 3 | 1 | 2 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 3 | 2 | 0 | 0 | 114 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 2 | 2 | 1 | 0 | 123 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 240 | 1 | 3 | 0 | 0 | 122 | 1000000000136.38 | 1000000000137.82 | 576 | 9792 (10 rows) ``` # SVCS\$1QUERY\$1SUMMARY SVCS\$1QUERY\$1SUMMARY Utilice la vista SVCS\$1QUERY\$1SUMMARY para encontrar información general acerca de la ejecución de una consulta. Tenga en cuenta que la información en SVCS\$1QUERY\$1SUMMARY proviene de todos los nodos. **nota** La vista SVCS\$1QUERY\$1SUMMARY solo tiene información relacionada con las consultas completadas por Amazon Redshift, no otros comandos de utilidades ni de DDL. Para obtener una lista completa e información sobre todas las instrucciones completadas por Amazon Redshift, incluidos los comandos de DDL y de utilidades, puede consultar la vista SVL\$1STATEMENTTEXT. Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1QUERY\$1SUMMARY. 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. Para obtener información sobre SVL\$1QUERY\$1SUMMARY, consulte [SVL\$1QUERY\$1SUMMARY](r_SVL_QUERY_SUMMARY.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_QUERY_SUMMARY.html) ## Consultas de ejemplo Consultas de ejemplo **Vista de la información de procesamiento del paso de una consulta** En la siguiente consulta, se muestra la información básica de procesamiento para cada paso de la consulta 87: ``` select query, stm, seg, step, rows, bytes from svcs_query_summary where query = 87 order by query, seg, step; ``` Esta consulta recupera la información de procesamiento acerca de la consulta 87, tal como se muestra en el siguiente ejemplo de salida: ``` query | stm | seg | step | rows | bytes -------+-----+-----+------+--------+--------- 87 | 0 | 0 | 0 | 90 | 1890 87 | 0 | 0 | 2 | 90 | 360 87 | 0 | 1 | 0 | 90 | 360 87 | 0 | 1 | 2 | 90 | 1440 87 | 1 | 2 | 0 | 210494 | 4209880 87 | 1 | 2 | 3 | 89500 | 0 87 | 1 | 2 | 6 | 4 | 96 87 | 2 | 3 | 0 | 4 | 96 87 | 2 | 3 | 1 | 4 | 96 87 | 2 | 4 | 0 | 4 | 96 87 | 2 | 4 | 1 | 1 | 24 87 | 3 | 5 | 0 | 1 | 24 87 | 3 | 5 | 4 | 0 | 0 (13 rows) ``` **Determinar qué pasos de la consulta se vertieron en el disco** En la siguiente consulta, se muestra si alguno de los pasos de la consulta con el ID de consulta 1025 (ver la vista [SVL\$1QLOG](r_SVL_QLOG.md) para saber cómo obtener el ID de una consulta) se vertieron al disco o si la consulta se ejecutó en su totalidad en la memoria: ``` select query, step, rows, workmem, label, is_diskbased from svcs_query_summary where query = 1025 order by workmem desc; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` query| step| rows | workmem | label | is_diskbased -----+-----+--------+-----------+---------------+-------------- 1025 | 0 |16000000| 141557760 |scan tbl=9 | f 1025 | 2 |16000000| 135266304 |hash tbl=142 | t 1025 | 0 |16000000| 128974848 |scan tbl=116536| f 1025 | 2 |16000000| 122683392 |dist | f (4 rows) ``` Al examinar los valores para IS\$1DISKBASED, puede ver qué pasos de la consulta pasaron al disco. Para la consulta 1025, el paso hash se ejecutó en el disco. Los pasos que se pueden ejecutar en el disco incluyen los pasos hash, aggr y sort. Para ver únicamente los pasos de la consulta basados en el disco, agregue la cláusula **and is\$1diskbased = 't'** a la instrucción SQL del ejemplo anterior. # SVCS\$1S3LIST SVCS\$1S3LIST Utilice la vista SVCS\$1S3LIST para obtener detalles acerca de las consultas de Amazon Redshift Spectrum en el nivel de segmento. Un segmento puede realizar un análisis de tablas externas. Esta vista se obtiene de la vista del sistema SVL\$1S3LIST, pero no muestra el sector de las consultas ejecutadas en un clúster de escalado de simultaneidad. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1S3LIST. 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). Para obtener más información sobre SVL\$1S3LIST, consulte [SVL\$1S3LIST](r_SVL_S3LIST.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_S3LIST.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se consulta SVCS\$1S3LIST para obtener la última consulta realizada. ``` select * from svcs_s3list where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3LOG SVCS\$1S3LOG Utilice la vista SVCS\$1S3LOG para obtener detalles acerca de la resolución de problemas de las consultas de Redshift Spectrum en el nivel de segmento. Un segmento puede realizar un análisis de tablas externas. Esta vista se obtiene de la vista del sistema SVL\$1S3LOG, pero no muestra el sector de las consultas ejecutadas en un clúster de escalado de simultaneidad. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1S3LOG. 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). Para obtener más información sobre SVL\$1S3LOG, consulte [SVL\$1S3LOG](r_SVL_S3LOG.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_S3LOG.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se consulta SVCS\$1S3LOG para obtener la última consulta ejecutada. ``` select * from svcs_s3log where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3PARTITION\$1SUMMARY SVCS\$1S3PARTITION\$1SUMMARY Utilice la vista SVCS\$1S3PARTITION\$1SUMMARY para obtener un resumen de la partición de consultas de Redshift Spectrum que se procesa en el nivel de segmento. Un segmento puede realizar un análisis de tablas externas. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1S3PARTITION\$1SUMMARY. 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). Para obtener más información sobre SVL\$1S3PARTITION, consulte [SVL\$1S3PARTITION](r_SVL_S3PARTITION.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_S3PARTITION_SUMMARY.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se obtienen los detalles del análisis de partición de la última consulta realizada. ``` select query, segment, assignment, min_starttime, max_endtime, min_duration, avg_duration from svcs_s3partition_summary where query = pg_last_query_id() order by query,segment; ``` # SVCS\$1S3QUERY\$1SUMMARY SVCS\$1S3QUERY\$1SUMMARY Utilice la vista SVCS\$1S3QUERY\$1SUMMARY para obtener un resumen de todas las consultas de Redshift Spectrum (consultas de S3) que se ejecutaron en el sistema. Un segmento puede realizar un análisis de tablas externas. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las vista con el prefijo SVL, con la salvedad de que las vistas SVL solo proporcionan información para las consultas ejecutadas en el clúster principal. Todos los usuarios pueden ver SVCS\$1S3QUERY\$1SUMMARY. 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). Para obtener más información sobre SVL\$1S3QUERY, consulte [SVL\$1S3QUERY](r_SVL_S3QUERY.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_S3QUERY_SUMMARY.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se obtienen los detalles del paso de examen para la última consulta ejecutada. ``` select query, segment, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files from svcs_s3query_summary where query = pg_last_query_id() order by query,segment; ``` ``` query | segment | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files ------+---------+---------+-----------------+------------------+-----------------------+------------------------+------ 4587 | 2 | 67811 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1 4587 | 2 | 216849 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 216671 | 0 | 0 | 0 | 0 | 0 ``` # SVCS\$1STREAM\$1SEGS SVCS\$1STREAM\$1SEGS Muestra la relación entre las secuencias y los segmentos simultáneos. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. SVCS\$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). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_STREAM_SEGS.html) ## Consultas de ejemplo 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 svcs_stream_segs where query = pg_last_query_id(); query | stream | segment -------+--------+--------- 10 | 1 | 2 10 | 0 | 0 10 | 2 | 4 10 | 1 | 3 10 | 0 | 1 (5 rows) ``` # SVCS\$1UNLOAD\$1LOG SVCS\$1UNLOAD\$1LOG Utilice SVCS\$1UNLOAD\$1LOG para obtener los detalles de las operaciones UNLOAD. SVCS\$1UNLOAD\$1LOG registra una fila por cada archivo creado por una instrucción UNLOAD. Por ejemplo, si una instrucción UNLOAD crea 12 archivos, SVCS\$1UNLOAD\$1LOG tendrá 12 filas correspondientes. Esta vista se obtiene de la tabla del sistema STL\$1UNLOAD\$1LOG, pero no muestra el sector de las consultas ejecutadas en un clúster de escalado de simultaneidad. **nota** Las vistas del sistema con el prefijo SVCS proporcionan información sobre las consultas de los clústeres principal y de escalado de simultaneidad. Las vistas son similares a las tablas con el prefijo STL, con la salvedad de que las tablas STL solo proporcionan información para las consultas ejecutadas en el clúster principal. SVCS\$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). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVCS_UNLOAD_LOG.html) ## Consulta de ejemplo 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. Sin embargo, en función de la rapidez con la que se emita la llamada, la lista podría estar incompleta, ya que las operaciones de lista de Amazon S3 tienen consistencia final. Para obtener una lista oficial completa de inmediato, consulte SVCS\$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 svcs_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) ``` # Vistas de SVL para el clúster principal Vistas SVL para el clúster principal Las vistas de SVL son vistas del sistema en Amazon Redshift que contienen referencias a tablas y registros STL donde puede obtener información más detallada. Estas vistas proporcionan un acceso más rápido y fácil a los datos más consultados que se encuentran en esas tablas. **nota** La vista SVL\$1QUERY\$1SUMMARY solo contiene información relacionada con las consultas ejecutadas por Amazon Redshift, no otros comandos de utilidades ni de DDL. Para obtener una lista completa e información acerca de todas las instrucciones ejecutadas por Amazon Redshift, incluidos los comandos de DDL y de utilidades, puede consultar la vista SVL\$1STATEMENTTEXT. **Topics** + [ # SVL\$1AUTO\$1WORKER\$1ACTION ](r_SVL_AUTO_WORKER_ACTION.md) + [ # SVL\$1COMPILE ](r_SVL_COMPILE.md) + [ # SVL\$1DATASHARE\$1CHANGE\$1LOG ](r_SVL_DATASHARE_CHANGE_LOG.md) + [ # SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE ](r_SVL_DATASHARE_CROSS_REGION_USAGE.md) + [ # SVL\$1DATASHARE\$1USAGE\$1CONSUMER ](r_SVL_DATASHARE_USAGE_CONSUMER.md) + [ # SVL\$1DATASHARE\$1USAGE\$1PRODUCER ](r_SVL_DATASHARE_USAGE_PRODUCER.md) + [ # SVL\$1FEDERATED\$1QUERY ](r_SVL_FEDERATED_QUERY.md) + [ # SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS ](r_SVL_MULTI_STATEMENT_VIOLATIONS.md) + [ # SVL\$1MV\$1REFRESH\$1STATUS ](r_SVL_MV_REFRESH_STATUS.md) + [ # SVL\$1QERROR ](r_SVL_QERROR.md) + [ # SVL\$1QLOG ](r_SVL_QLOG.md) + [ # SVL\$1QUERY\$1METRICS ](r_SVL_QUERY_METRICS.md) + [ # SVL\$1QUERY\$1METRICS\$1SUMMARY ](r_SVL_QUERY_METRICS_SUMMARY.md) + [ # SVL\$1QUERY\$1QUEUE\$1INFO ](r_SVL_QUERY_QUEUE_INFO.md) + [ # SVL\$1QUERY\$1REPORT ](r_SVL_QUERY_REPORT.md) + [ # SVL\$1QUERY\$1SUMMARY ](r_SVL_QUERY_SUMMARY.md) + [ # SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS ](r_SVL_RESTORE_ALTER_TABLE_PROGRESS.md) + [ # SVL\$1S3LIST ](r_SVL_S3LIST.md) + [ # SVL\$1S3LOG ](r_SVL_S3LOG.md) + [ # SVL\$1S3PARTITION ](r_SVL_S3PARTITION.md) + [ # SVL\$1S3PARTITION\$1SUMMARY ](r_SVL_S3PARTITION_SUMMARY.md) + [ # SVL\$1S3QUERY ](r_SVL_S3QUERY.md) + [ # SVL\$1S3QUERY\$1SUMMARY ](r_SVL_S3QUERY_SUMMARY.md) + [ # SVL\$1S3RETRIES ](r_SVL_S3RETRIES.md) + [ # SVL\$1SPATIAL\$1SIMPLIFY ](r_SVL_SPATIAL_SIMPLIFY.md) + [ # SVL\$1SPECTRUM\$1SCAN\$1ERROR ](r_SVL_SPECTRUM_SCAN_ERROR.md) + [ # SVL\$1STATEMENTTEXT ](r_SVL_STATEMENTTEXT.md) + [ # SVL\$1STORED\$1PROC\$1CALL ](r_SVL_STORED_PROC_CALL.md) + [ # SVL\$1STORED\$1PROC\$1MESSAGES ](r_SVL_STORED_PROC_MESSAGES.md) + [ # SVL\$1TERMINATE ](r_SVL_TERMINATE.md) + [ # SVL\$1UDF\$1LOG ](r_SVL_UDF_LOG.md) + [ # SVL\$1USER\$1INFO ](r_SVL_USER_INFO.md) + [ # SVL\$1VACUUM\$1PERCENTAGE ](r_SVL_VACUUM_PERCENTAGE.md) # SVL\$1AUTO\$1WORKER\$1ACTION SVL\$1AUTO\$1WORKER\$1ACTION Registra las acciones automatizadas realizadas por Amazon Redshift en tablas definidas para la optimización automática. SVL\$1AUTO\$1WORKER\$1ACTION es visible solo 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_AUTO_WORKER_ACTION.html) Algunos ejemplos de valores de la columna `status` son los siguientes: + Skipped:Table not found. + Skipped:Recommendation is empty. + Skipped:Apply sortkey recommendation is disabled. + Skipped:Retry exceeds the maximum limit for a table. + Skipped:Table column has changed. + Abort:This table is not AUTO. + Abort:This table has been recently converted. + Abort:This table exceeds table size threshold. + Abort:This table is already the recommended style. + Checkpoint: progress *21.9963*%. ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, las filas del resultado muestran las acciones realizadas por Amazon Redshift. ``` select table_id, type, status, eventtime, sequence, previous_state from SVL_AUTO_WORKER_ACTION; ``` ``` table_id | type | status | eventtime | sequence | previous_state ----------+---------+------------------------------------------------------+----------------------------+----------+---------------- 118082 | sortkey | Start | 2020-08-22 19:42:20.727049 | 0 | 118078 | sortkey | Start | 2020-08-22 19:43:54.728819 | 0 | 118082 | sortkey | Start | 2020-08-22 19:42:52.690264 | 0 | 118072 | sortkey | Start | 2020-08-22 19:44:14.793572 | 0 | 118082 | sortkey | Failed | 2020-08-22 19:42:20.728917 | 0 | 118078 | sortkey | Complete | 2020-08-22 19:43:54.792705 | 0 | SORTKEY: None; 118086 | sortkey | Complete | 2020-08-22 19:42:00.72635 | 0 | SORTKEY: None; 118082 | sortkey | Complete | 2020-08-22 19:43:34.728144 | 0 | SORTKEY: None; 118072 | sortkey | Skipped:Retry exceeds the maximum limit for a table. | 2020-08-22 19:44:46.706155 | 0 | 118086 | sortkey | Start | 2020-08-22 19:42:00.685255 | 0 | 118082 | sortkey | Start | 2020-08-22 19:43:34.69531 | 0 | 118072 | sortkey | Start | 2020-08-22 19:44:46.703331 | 0 | 118082 | sortkey | Checkpoint: progress 14.755079% | 2020-08-22 19:42:52.692828 | 0 | 118072 | sortkey | Failed | 2020-08-22 19:44:14.796071 | 0 | 116723 | sortkey | Abort:This table is not AUTO. | 2020-10-28 05:12:58.479233 | 0 | 110203 | distkey | Abort:This table is not AUTO. | 2020-10-28 05:45:54.67259 | 0 | ``` # SVL\$1COMPILE SVL\$1COMPILE Registra el tiempo de compilación y la ubicación de cada segmento de una determinada consulta. SVL\$1COMPILE 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** SVL\$1COMPILE 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\$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. Para obtener más información sobre SVCS\$1COMPILE, consulte [SVCS\$1COMPILE](r_SVCS_COMPILE.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_COMPILE.html) ## Consultas de ejemplo Consultas de ejemplo En este ejemplo, las consultas 35878 y 35879 ejecutaron la misma instrucción SQL. La columna de compilación para la consulta 35878 muestra `1` para cuatro segmentos de consulta, lo que indica que esos segmentos se compilaron. La consulta 35879 muestra `0` en la columna de compilación para cada segmento, lo que indica que esos segmentos no se volvieron a compilar. ``` select userid, xid, pid, query, segment, locus, datediff(ms, starttime, endtime) as duration, compile from svl_compile where query = 35878 or query = 35879 order by query, segment; userid | xid | pid | query | segment | locus | duration | compile --------+--------+-------+-------+---------+-------+----------+--------- 100 | 112780 | 23028 | 35878 | 0 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 1 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 2 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 3 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 4 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 5 | 1 | 0 | 0 100 | 112780 | 23028 | 35878 | 6 | 1 | 1380 | 1 100 | 112780 | 23028 | 35878 | 7 | 1 | 1085 | 1 100 | 112780 | 23028 | 35878 | 8 | 1 | 1197 | 1 100 | 112780 | 23028 | 35878 | 9 | 2 | 905 | 1 100 | 112782 | 23028 | 35879 | 0 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 1 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 2 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 3 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 4 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 5 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 6 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 7 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 8 | 1 | 0 | 0 100 | 112782 | 23028 | 35879 | 9 | 2 | 0 | 0 (20 rows) ``` # SVL\$1DATASHARE\$1CHANGE\$1LOG SVL\$1DATASHARE\$1CHANGE\$1LOG Registra la vista consolidada para realizar el seguimiento de los cambios en los datashares (recursos para compartir datos) tanto en los clústeres productores como en los consumidores. SVL\$1DATASHARE\$1CHANGE\$1LOG es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1DATASHARE\$1CHANGE\$1LOG](SYS_DATASHARE_CHANGE_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_DATASHARE_CHANGE_LOG.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SVL\$1DATASHARE\$1CHANGE\$1LOG. ``` SELECT DISTINCT action FROM svl_datashare_change_log WHERE share_object_name LIKE 'tickit%'; action ----------------------- "ALTER DATASHARE ADD" ``` # SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE Utilice la vista SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE para obtener un resumen del uso de datos transferidos entre regiones debido a la consulta de uso compartido de datos entre regiones. SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE agrega detalles en el nivel de segmento. SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE 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\$1DATASHARE\$1CROSS\$1REGION\$1USAGE](r_SYS_DATASHARE_CROSS_REGION_USAGE.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_DATASHARE_CROSS_REGION_USAGE.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SVL\$1DATASHARE\$1CROSS\$1REGION\$1USAGE. ``` SELECT query, segment, transferred_data, source_region from svl_datashare_cross_region_usage where query = pg_last_query_id() order by query,segment; query | segment | transferred_data | source_region --------+---------+------------------+--------------- 200048 | 2 | 4194304 | us-west-1 200048 | 2 | 4194304 | us-east-2 ``` # SVL\$1DATASHARE\$1USAGE\$1CONSUMER SVL\$1DATASHARE\$1USAGE\$1CONSUMER Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster consumidor. SVL\$1DATASHARE\$1USAGE\$1CONSUMER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1DATASHARE\$1USAGE\$1CONSUMER](SYS_DATASHARE_USAGE_CONSUMER.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_DATASHARE_USAGE_CONSUMER.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SVL\$1DATASHARE\$1USAGE\$1CONSUMER. ``` SELECT request_type, status, trim(error) AS error FROM svl_datashare_usage_consumer request_type | status | error ----------------+--------+-------- "GET RELATION" | 0 | ``` # SVL\$1DATASHARE\$1USAGE\$1PRODUCER SVL\$1DATASHARE\$1USAGE\$1PRODUCER Registra la actividad y el uso de los datashares. Esta vista solo es relevante en el clúster productor. SVL\$1DATASHARE\$1USAGE\$1PRODUCER es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1DATASHARE\$1USAGE\$1PRODUCER](SYS_DATASHARE_USAGE_PRODUCER.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_DATASHARE_USAGE_PRODUCER.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra una vista SVL\$1DATASHARE\$1USAGE\$1PRODUCER. ``` SELECT DISTINCT request_type FROM svl_datashare_usage_producer WHERE object_name LIKE 'tickit%'; request_type ------------------ "GET RELATION" ``` # SVL\$1FEDERATED\$1QUERY SVL\$1FEDERATED\$1QUERY Utilice la vista SVL\$1FEDERATED\$1QUERY para ver información sobre una llamada a consulta federada. SVL\$1FEDERATED\$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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_FEDERATED_QUERY.html) ## Consultas de ejemplo Consultas de ejemplo Para mostrar información acerca de las llamadas a consultas federadas, ejecute la siguiente consulta. ``` select query, trim(sourcetype) as type, recordtime, trim(querytext) as "PG Subquery" from svl_federated_query where query = 4292; query | type | recordtime | pg subquery -------+------+----------------------------+--------------------------------------------------------------- 4292 | PG | 2020-03-27 04:29:58.485126 | SELECT "level" FROM functional.employees WHERE ("level" >= 6) (1 row) ``` # SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS Utilice la vista SVL\$1MULTI\$1STATEMENT\$1VIOLATIONS para obtener un registro completo de todos los comandos SQL que se ejecutan en el sistema e infringen las restricciones de bloque de transacciones. Las infracciones se producen cuando ejecuta cualquiera de los siguientes comandos SQL que Amazon Redshift restringe dentro de un bloque de transacción o solicitudes de varias instrucciones: + [CREATE DATABASE](r_CREATE_DATABASE.md) + [DROP DATABASE](r_DROP_DATABASE.md) + [ALTER TABLE APPEND](r_ALTER_TABLE_APPEND.md) + [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md) + DROP EXTERNAL TABLE + RENAME EXTERNAL TABLE + ALTER EXTERNAL TABLE + CREATE TABLESPACE + DROP TABLESPACE + [CREATE LIBRARY](r_CREATE_LIBRARY.md) + [DROP LIBRARY](r_DROP_LIBRARY.md) + REBUILDCAT + INDEXCAT + REINDEX DATABASE + [VACUUM](r_VACUUM_command.md) + [GRANT](r_GRANT.md) + [COPY](r_COPY.md) **nota** Si hay entradas en esta vista, cambie las aplicaciones y los scripts SQL correspondientes. Se recomienda cambiar el código de la aplicación para mover el uso de estos comandos SQL restringidos fuera del bloque de transacciones. Si necesita asistencia adicional, contacte con AWS Support. SVL\$1MULTI\$1STATEMENT\$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\$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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_MULTI_STATEMENT_VIOLATIONS.html) ## Consulta de ejemplo Consulta de ejemplo En la siguiente consulta se devuelven varias instrucciones que tienen infracciones. ``` select * from svl_multi_statement_violations order by starttime asc; userid | database | cmdname | xid | pid | label | starttime | endtime | sequence | type | text ============================================================================================================================== 1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | DDL | create table c(b int); 1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | UTILITY | create database b; 1 | dev | CREATE DATABASE | 1034 | 5729 |label1 | ********* | ******* | 0 | UTILITY | COMMIT ... ``` # SVL\$1MV\$1REFRESH\$1STATUS SVL\$1MV\$1REFRESH\$1STATUS La vista SVL\$1MV\$1REFRESH\$1STATUS contiene una fila para la actividad de actualización de las vistas materializadas. Para obtener más información acerca de las vistas materializadas, consulte [Vistas materializadas en Amazon Redshift](materialized-view-overview.md). SVL\$1MV\$1REFRESH\$1STATUS 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\$1REFRESH\$1HISTORY](SYS_MV_REFRESH_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_MV_REFRESH_STATUS.html) ## Consulta de ejemplo Consulta de ejemplo Para ver el estado de actualización de las vistas materializadas, ejecute la siguiente consulta. ``` select * from svl_mv_refresh_status; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` db_name | userid | schema | name | xid | starttime | endtime | status | refresh_type | consumer_account | consumer_region | consumer_namespace ---------+--------+-----------+---------+-------+----------------------------+----------------------------+-------------------------------------------------------------------------------------+---------------+------------------+-----------------+------------------------------------ dev | 169 | mv_schema | mv_test | 6640 | 2020-02-14 02:26:53.497935 | 2020-02-14 02:26:53.556156 | Refresh successfully recomputed MV from scratch | Manual | | | dev | 166 | mv_schema | mv_test | 6517 | 2020-02-14 02:26:39.287438 | 2020-02-14 02:26:39.349539 | Refresh successfully updated MV incrementally | Auto | | | ext_db | 162 | producer_schema | producer_mv | 6388 | 2020-02-14 02:26:27.863426 | 2020-02-14 02:26:27.918307 | Refresh successfully updated MV incrementally | Manual | 0123456789 | us-east-1 | 623d8ff2-4391-4381-83d7-177caa6767af dev | 161 | mv_schema | mv_test | 6323 | 2020-02-14 02:26:20.020717 | 2020-02-14 02:26:20.080002 | Refresh successfully updated MV incrementally | Auto | | | dev | 161 | mv_schema | mv_test | 6301 | 2020-02-14 02:26:05.796146 | 2020-02-14 02:26:07.853986 | Refresh successfully recomputed MV from scratch | Manual | | | dev | 153 | mv_schema | mv_test | 6024 | 2020-02-14 02:25:18.762335 | 2020-02-14 02:25:20.043462 | MV was already updated | Manual | | | dev | 143 | mv_schema | mv_test | 5557 | 2020-02-14 02:24:23.100601 | 2020-02-14 02:24:23.100633 | MV was already updated | Manual dev | 141 | mv_schema | mv_test | 5447 | 2020-02-14 02:23:54.102837 | 2020-02-14 02:24:00.310166 | Refresh successfully updated MV incrementally | Auto dev | 1 | mv_schema | mv_test | 5329 | 2020-02-14 02:22:26.328481 | 2020-02-14 02:22:28.369217 | Refresh successfully recomputed MV from scratch | Auto dev | 138 | mv_schema | mv_test | 5290 | 2020-02-14 02:21:56.885093 | 2020-02-14 02:21:56.885098 | Refresh failed. MV was not found | Manual dev | 138 | mv_schema | mv_test | 5100 | 2020-02-14 02:20:33.123445 | 2020-02-14 02:20:33.123445 | Cascade refresh failed because materialized view mv_schema.child was not refreshed. | Manual dev | 138 | mv_schema | child | 5100 | 2020-02-14 02:20:33.123445 | 2020-02-14 02:20:33.123445 | Refresh failed due to an internal error. | Manual dev | 138 | mv_schema | mv_test | 5099 | 2020-02-14 02:10:23.492344 | 2020-02-14 02:10:23.492344 | Cascade refresh skipped because materialized view mv_schema.child was not refreshed.| Manual dev | 138 | mv_schema | child | 5099 | 2020-02-14 02:10:23.492344 | 2020-02-14 02:10:23.492344 | Refresh failed due to an internal error. | Manual ``` # SVL\$1QERROR SVL\$1QERROR La vista SVL\$1QERROR está en desuso. # SVL\$1QLOG SVL\$1QLOG La vista SVL\$1QLOG tiene un registro de todas las consultas que se ejecutan para la base de datos. Amazon Redshift crea la vista SVL\$1QLOG como un subconjunto legible de información de la tabla [STL\$1QUERY](r_STL_QUERY.md). Utilice esta tabla para encontrar el ID de consulta correspondiente a una consulta recientemente ejecutada o para ver cuánto demora en completarse una consulta. SVL\$1QLOG 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QLOG.html) ## Consultas de ejemplo Consultas de ejemplo El siguiente ejemplo devuelve el ID de la consulta, el tiempo de ejecución y el texto truncado de la consulta para las cinco consultas más recientes de base de datos ejecutadas por el usuario con `userid = 100`. ``` select query, pid, elapsed, substring from svl_qlog where userid = 100 order by starttime desc limit 5; query | pid | elapsed | substring --------+-------+----------+----------------------------------------------- 187752 | 18921 | 18465685 | select query, elapsed, substring from svl_... 204168 | 5117 | 59603 | insert into testtable values (100); 187561 | 17046 | 1003052 | select * from pg_table_def where tablename... 187549 | 17046 | 1108584 | select * from STV_WLM_SERVICE_CLASS_CONFIG 187468 | 17046 | 5670661 | select * from pg_table_def where schemaname... (5 rows) ``` El siguiente ejemplo devuelve el nombre del script SQL (columna LABEL) y el tiempo transcurrido en una consulta que se canceló (**aborted=1**): ``` select query, elapsed, trim(label) querylabel from svl_qlog where aborted=1; query | elapsed | querylabel -------+----------+------------------------- 16 | 6935292 | alltickittablesjoin.sql (1 row) ``` # SVL\$1QUERY\$1METRICS SVL\$1QUERY\$1METRICS La vista SVL\$1QUERY\$1METRICS muestra las métricas de consultas completadas. Esta vista se deriva de la tabla de sistema [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md). Utilice los valores de esta vista como ayuda para determinar los valores de umbral destinados a definir las reglas de supervisión de consultas. Para obtener más información, consulte [Reglas de monitoreo de consultas de WLM](cm-c-wlm-query-monitoring-rules.md). SVL\$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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QUERY_METRICS.html) # SVL\$1QUERY\$1METRICS\$1SUMMARY SVL\$1QUERY\$1METRICS\$1SUMMARY La vista SVL\$1QUERY\$1METRICS\$1SUMMARY muestra los valores máximos de métricas de consultas completadas. Esta vista se deriva de la tabla de sistema [STL\$1QUERY\$1METRICS](r_STL_QUERY_METRICS.md). Utilice los valores de esta vista como ayuda para determinar los valores de umbral destinados a definir las reglas de supervisión de consultas. Para obtener más información sobre las reglas y métricas para monitorear consultas para Amazon Redshift, consulte [Reglas de monitoreo de consultas de WLM](cm-c-wlm-query-monitoring-rules.md). SVL\$1QUERY\$1METRICS\$1SUMMARY 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QUERY_METRICS_SUMMARY.html) # SVL\$1QUERY\$1QUEUE\$1INFO SVL\$1QUERY\$1QUEUE\$1INFO Resume los detalles de las consultas que pasan tiempo en una cola de consultas o en una cola de confirmación de Workload Management (WLM, Administración de cargas de trabajo). La vista SVL\$1QUERY\$1QUEUE\$1INFO filtra las consultas realizadas por el sistema y muestra solo las realizadas por un usuario. La vista SVL\$1QUERY\$1QUEUE\$1INFO resume información acerca de las tablas de sistema [STL\$1QUERY](r_STL_QUERY.md), [STL\$1WLM\$1QUERY](r_STL_WLM_QUERY.md) y [STL\$1COMMIT\$1STATS](r_STL_COMMIT_STATS.md). SVL\$1QUERY\$1QUEUE\$1INFO 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QUERY_QUEUE_INFO.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra el tiempo en que las consultas estuvieron en colas de WLM. ``` select query, service_class, queue_elapsed, exec_elapsed, wlm_total_elapsed from svl_query_queue_info where wlm_total_elapsed > 0; query | service_class | queue_elapsed | exec_elapsed | wlm_total_elapsed ---------+---------------+---------------+--------------+------------------- 2742669 | 6 | 2 | 916 | 918 2742668 | 6 | 4 | 197 | 201 (2 rows) ``` # SVL\$1QUERY\$1REPORT SVL\$1QUERY\$1REPORT Amazon Redshift crea la vista SVL\$1QUERY\$1REPORT de una función UNION de una cantidad de tablas de sistema STL de Amazon Redshift para proporcionar información acerca de los pasos completados de la consulta. Esta vista desglosa la información relacionada con las consultas completadas por sector y por paso, lo que puede ayudar con el nodo de solución de problemas y con los problemas del sector en el clúster de Amazon Redshift. SVL\$1QUERY\$1REPORT 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QUERY_REPORT.html) ## Consultas de ejemplo Consultas de ejemplo En la siguiente consulta, se demuestra el sesgo de datos de las filas devueltas para la consulta con el ID de consulta 279. Utilice esta consulta para determinar si los datos de la base de datos están distribuidos uniformemente en los sectores en el clúster del data warehouse: ``` select query, segment, step, max(rows), min(rows), case when sum(rows) > 0 then ((cast(max(rows) -min(rows) as float)*count(rows))/sum(rows)) else 0 end from svl_query_report where query = 279 group by query, segment, step order by segment, step; ``` Esta consulta debe devolver datos similares al siguiente ejemplo de salida: ``` query | segment | step | max | min | case ------+---------+------+----------+----------+---------------------- 279 | 0 | 0 | 19721687 | 19721687 | 0 279 | 0 | 1 | 19721687 | 19721687 | 0 279 | 1 | 0 | 986085 | 986084 | 1.01411202804304e-06 279 | 1 | 1 | 986085 | 986084 | 1.01411202804304e-06 279 | 1 | 4 | 986085 | 986084 | 1.01411202804304e-06 279 | 2 | 0 | 1775517 | 788460 | 1.00098637606408 279 | 2 | 2 | 1775517 | 788460 | 1.00098637606408 279 | 3 | 0 | 1775517 | 788460 | 1.00098637606408 279 | 3 | 2 | 1775517 | 788460 | 1.00098637606408 279 | 3 | 3 | 1775517 | 788460 | 1.00098637606408 279 | 4 | 0 | 1775517 | 788460 | 1.00098637606408 279 | 4 | 1 | 1775517 | 788460 | 1.00098637606408 279 | 4 | 2 | 1 | 1 | 0 279 | 5 | 0 | 1 | 1 | 0 279 | 5 | 1 | 1 | 1 | 0 279 | 6 | 0 | 20 | 20 | 0 279 | 6 | 1 | 1 | 1 | 0 279 | 7 | 0 | 1 | 1 | 0 279 | 7 | 1 | 0 | 0 | 0 (19 rows) ``` # SVL\$1QUERY\$1SUMMARY SVL\$1QUERY\$1SUMMARY Utilice la vista SVL\$1QUERY\$1SUMMARY para encontrar información general acerca de la ejecución de una consulta. La vista SVL\$1QUERY\$1SUMMARY tiene un subconjunto de datos de la vista SVL\$1QUERY\$1REPORT. Tenga en cuenta que la información en SVL\$1QUERY\$1SUMMARY proviene de todos los nodos. **nota** La vista SVL\$1QUERY\$1SUMMARY solo contiene información relacionada con las consultas realizadas por Amazon Redshift, no otros comandos de utilidades ni de DDL. Para obtener una lista completa e información acerca de todas las instrucciones realizadas por Amazon Redshift, incluidos los comandos de DDL y de utilidades, puede consultar la vista SVL\$1STATEMENTTEXT. SVL\$1QUERY\$1SUMMARY 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. Para obtener más información sobre SVCS\$1QUERY\$1SUMMARY, consulte [SVCS\$1QUERY\$1SUMMARY](r_SVCS_QUERY_SUMMARY.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_QUERY_SUMMARY.html) ## Consultas de ejemplo Consultas de ejemplo **Vista de la información de procesamiento del paso de una consulta** En la siguiente consulta, se muestra la información básica de procesamiento para cada paso de la consulta 87: ``` select query, stm, seg, step, rows, bytes from svl_query_summary where query = 87 order by query, seg, step; ``` Esta consulta recupera la información de procesamiento acerca de la consulta 87, tal como se muestra en el siguiente ejemplo de salida: ``` query | stm | seg | step | rows | bytes -------+-----+-----+------+--------+--------- 87 | 0 | 0 | 0 | 90 | 1890 87 | 0 | 0 | 2 | 90 | 360 87 | 0 | 1 | 0 | 90 | 360 87 | 0 | 1 | 2 | 90 | 1440 87 | 1 | 2 | 0 | 210494 | 4209880 87 | 1 | 2 | 3 | 89500 | 0 87 | 1 | 2 | 6 | 4 | 96 87 | 2 | 3 | 0 | 4 | 96 87 | 2 | 3 | 1 | 4 | 96 87 | 2 | 4 | 0 | 4 | 96 87 | 2 | 4 | 1 | 1 | 24 87 | 3 | 5 | 0 | 1 | 24 87 | 3 | 5 | 4 | 0 | 0 (13 rows) ``` **Determinar qué pasos de la consulta se vertieron en el disco** En la siguiente consulta, se muestra si alguno de los pasos de la consulta con el ID de consulta 1025 (ver la vista [SVL\$1QLOG](r_SVL_QLOG.md) para saber cómo obtener el ID de una consulta) se vertieron al disco o si la consulta se ejecutó en su totalidad en la memoria: ``` select query, step, rows, workmem, label, is_diskbased from svl_query_summary where query = 1025 order by workmem desc; ``` Esta consulta devuelve el siguiente ejemplo de salida: ``` query| step| rows | workmem | label | is_diskbased -----+-----+--------+-----------+---------------+-------------- 1025 | 0 |16000000| 141557760 |scan tbl=9 | f 1025 | 2 |16000000| 135266304 |hash tbl=142 | t 1025 | 0 |16000000| 128974848 |scan tbl=116536| f 1025 | 2 |16000000| 122683392 |dist | f (4 rows) ``` Al examinar los valores para IS\$1DISKBASED, puede ver qué pasos de la consulta pasaron al disco. Para la consulta 1025, el paso hash se ejecutó en el disco. Los pasos que se pueden ejecutar en el disco incluyen los pasos hash, aggr y sort. Para ver únicamente los pasos de la consulta basados en el disco, agregue la cláusula **and is\$1diskbased = 't'** a la instrucción SQL del ejemplo anterior. # SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS Utilice SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS para monitorear el progreso de la migración de cada tabla del clúster durante un cambio de tamaño clásico en los nodos RA3. Captura el rendimiento histórico de la migración de datos durante la operación de cambio de tamaño. Para obtener más información sobre el cambio de tamaño clásico a los nodos RA3, consulte [Cambio de tamaño clásico](https://docs.aws.amazon.com/redshift/latest/mgmt/managing-cluster-operations.html#classic-resize-faster). SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS 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\$1RESTORE\$1LOG](SYS_RESTORE_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. **nota** Las filas con un progreso de `100.00%` o `ABORTED` se eliminan después de 7 días. Las filas de las tablas eliminadas durante o después de un cambio de tamaño clásico pueden seguir apareciendo en SVL\$1RESTORE\$1ALTER\$1TABLE\$1PROGRESS. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_RESTORE_ALTER_TABLE_PROGRESS.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve consultas en ejecución y en cola. ``` select * from svl_restore_alter_table_progress; tbl | progress | message --------+----------+----------------------------------------------------------- 105614 | ABORTED | Abort:Table no longer contains the prior dist key column. 105610 | ABORTED | Abort:Table no longer contains the prior dist key column. 105594 | 0.00% | Table waiting for alter diststyle conversion. 105602 | ABORTED | Abort:Table no longer contains the prior dist key column. 105606 | ABORTED | Abort:Table no longer contains the prior dist key column. 105598 | 100.00% | Restored to distkey successfully. ``` # SVL\$1S3LIST SVL\$1S3LIST Utilice la vista SVL\$1S3LIST para obtener detalles acerca de las consultas de Amazon Redshift Spectrum en el nivel de segmento. SVL\$1S3LIST 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** SVL\$1S3LIST 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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3LIST.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se consulta SVL\$1S3LIST para obtener la última consulta que se va a ejecutar. ``` select * from svl_s3list where query = pg_last_query_id() order by query,segment; ``` # SVL\$1S3LOG SVL\$1S3LOG Utilice la vista SVL\$1S3LOG para obtener detalles acerca de las consultas de Amazon Redshift Spectrum en el nivel de segmento y de sector del nodo. SVL\$1S3LOG 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** SVL\$1S3LOG 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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3LOG.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se consulta SVL\$1S3LOG para obtener la última consulta que se ejecutó. ``` select * from svl_s3log where query = pg_last_query_id() order by query,segment,slice; ``` # SVL\$1S3PARTITION SVL\$1S3PARTITION Utilice la vista SVL\$1S3PARTITION para obtener detalles acerca de las particiones de Amazon Redshift Spectrum en el nivel de segmento y de sector del nodo. SVL\$1S3PARTITION 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** SVL\$1S3PARTITION 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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3PARTITION.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se obtienen los detalles de partición de la última consulta completada. ``` SELECT query, segment, MIN(starttime) AS starttime, MAX(endtime) AS endtime, datediff(ms,MIN(starttime),MAX(endtime)) AS dur_ms, MAX(total_partitions) AS total_partitions, MAX(qualified_partitions) AS qualified_partitions, MAX(assignment) as assignment_type FROM svl_s3partition WHERE query=pg_last_query_id() GROUP BY query, segment ``` ``` query | segment | starttime | endtime | dur_ms| total_partitions | qualified_partitions | assignment_type ------+---------+-------------------------------+-----------------------------+-------+------------------+----------------------+---------------- 99232 | 0 | 2018-04-17 22:43:50.201515 | 2018-04-17 22:43:54.674595 | 4473 | 2526 | 334 | p ``` # SVL\$1S3PARTITION\$1SUMMARY SVL\$1S3PARTITION\$1SUMMARY Utilice la vista SVL\$1S3PARTITION\$1SUMMARY para obtener un resumen de las particiones de consultas de Redshift Spectrum que se procesan en el nivel de segmento. SVL\$1S3PARTITION\$1SUMMARY 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). Para obtener más información sobre SVCS\$1S3PARTITION, consulte [SVCS\$1S3PARTITION\$1SUMMARY](r_SVCS_S3PARTITION_SUMMARY.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3PARTITION_SUMMARY.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se obtienen los detalles de análisis de partición para la última consulta completada. ``` select query, segment, assignment, min_starttime, max_endtime, min_duration, avg_duration from svl_s3partition_summary where query = pg_last_query_id() order by query,segment; ``` # SVL\$1S3QUERY SVL\$1S3QUERY Utilice la vista SVL\$1S3QUERY para obtener detalles acerca de las consultas de Amazon Redshift Spectrum en el nivel de segmento y de sector del nodo. SVL\$1S3QUERY 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** SVL\$1S3QUERY 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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3QUERY.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se obtienen los detalles del paso de análisis para la última consulta completada. ``` select query, segment, slice, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files from svl_s3query where query = pg_last_query_id() order by query,segment,slice; ``` ``` query | segment | slice | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files ------+---------+-------+---------+-----------------+------------------+-----------------------+------------------------+------ 4587 | 2 | 0 | 67811 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 1 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1 4587 | 2 | 2 | 216849 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 3 | 216671 | 0 | 0 | 0 | 0 | 0 ``` # SVL\$1S3QUERY\$1SUMMARY SVL\$1S3QUERY\$1SUMMARY Utilice la vista SVL\$1S3QUERY\$1SUMMARY para obtener un resumen de todas las consultas de Amazon Redshift Spectrum (consultas S3) que se ejecutaron en el sistema. SVL\$1S3QUERY\$1SUMMARY agrega detalles de la vista SVL\$1S3QUERY a nivel segmento. SVL\$1S3QUERY\$1SUMMARY 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\$1EXTERNAL\$1QUERY\$1DETAIL](SYS_EXTERNAL_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. Para obtener más información sobre SVCS\$1S3QUERY\$1SUMMARY, consulte [SVCS\$1S3QUERY\$1SUMMARY](r_SVCS_S3QUERY_SUMMARY.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3QUERY_SUMMARY.html) ## Consulta de ejemplo Consultas de ejemplo En el siguiente ejemplo, se obtienen los detalles del paso de análisis para la última consulta completada. ``` select query, segment, elapsed, s3_scanned_rows, s3_scanned_bytes, s3query_returned_rows, s3query_returned_bytes, files from svl_s3query_summary where query = pg_last_query_id() order by query,segment; ``` ``` query | segment | elapsed | s3_scanned_rows | s3_scanned_bytes | s3query_returned_rows | s3query_returned_bytes | files ------+---------+---------+-----------------+------------------+-----------------------+------------------------+------ 4587 | 2 | 67811 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 591568 | 172462 | 11260097 | 8513 | 170260 | 1 4587 | 2 | 216849 | 0 | 0 | 0 | 0 | 0 4587 | 2 | 216671 | 0 | 0 | 0 | 0 | 0 ``` # SVL\$1S3RETRIES SVL\$1S3RETRIES Utilice la vista SVL\$1S3RETRIES para obtener información acerca de por qué se produjeron errores en una consulta de Amazon Redshift Spectrum basada en Amazon S3. SVL\$1S3RETRIES 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_S3RETRIES.html) ## Consulta de ejemplo Consulta de ejemplo En el siguiente ejemplo, se recuperan datos sobre consultas de S3 con errores. ``` SELECT svl_s3retries.query, svl_s3retries.segment, svl_s3retries.node, svl_s3retries.slice, svl_s3retries.eventtime, svl_s3retries.retries, svl_s3retries.successful_fetches, svl_s3retries.file_size, btrim((svl_s3retries."location")::text) AS "location", btrim((svl_s3retries.message)::text) AS message FROM svl_s3retries; ``` # SVL\$1SPATIAL\$1SIMPLIFY SVL\$1SPATIAL\$1SIMPLIFY Puede consultar la vista del sistema SVL\$1SPATIAL\$1SIMPLIFY para obtener información acerca de los objetos de geometría espacial simplificada mediante el comando COPY. Cuando utiliza COPY en un shapefile, puede especificar las opciones de ingesta SIMPLIFY `tolerance`, SIMPLIFY AUTO y SIMPLIFY AUTO `max_tolerance`. El resultado de la simplificación se resume en la vista de sistema SVL\$1SPATIAL\$1SIMPLIFY. Cuando se configura SIMPLIFY AUTO `max_tolerance`, esta vista contiene una fila para cada geometría que excedió el tamaño máximo. Cuando se configura SIMPLIFY `tolerance`, se almacena una fila para toda la operación COPY. Esta fila referencia el ID de consulta COPY y la tolerancia de simplificación especificada. SVL\$1SPATIAL\$1SIMPLIFY es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1SPATIAL\$1SIMPLIFY](SYS_SPATIAL_SIMPLIFY.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_SPATIAL_SIMPLIFY.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve la lista de registros que COPY simplificó. ``` SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id(); query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance -------+-------------+-------------------+--------------+------------+------------+---------------------- 20 | 1184704 | -1 | 1513736 | t | 1008808 | 1.276386653895e-05 20 | 1664115 | -1 | 1233456 | t | 1023584 | 6.11707814796635e-06 ``` # SVL\$1SPECTRUM\$1SCAN\$1ERROR SVL\$1SPECTRUM\$1SCAN\$1ERROR Puede consultar la vista del sistema SVL\$1SPECTRUM\$1SCAN\$1ERROR para obtener información acerca de los errores de análisis de Redshift Spectrum. SVL\$1SPECTRUM\$1SCAN\$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\$1EXTERNAL\$1QUERY\$1ERROR](SYS_EXTERNAL_QUERY_ERROR.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 Columnas de la tabla Muestra un ejemplo de errores registrados. El valor predeterminado es 10 entradas por consulta. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_SPECTRUM_SCAN_ERROR.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve la lista de filas para las que se han realizado operaciones de control de datos. ``` SELECT * FROM svl_spectrum_scan_error; ``` La consulta devuelve resultados similares a los siguientes. ``` userid query location rowid colname original_value modified_value trigger action action_valueerror_code 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:0 league_nspi 34595 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:1 league_nspi 34151 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:2 league_nspi 33223 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_name Barclays Premier League Barclays Premier Lea UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:3 league_nspi 32808 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:4 league_nspi 32790 32767 UNSPECIFIED OVERFLOW_VALUE 199 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:5 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156 100 1574007 s3://spectrum-uddh/league/spi_global_rankings.0:6 league_name Spanish Primera Division Spanish Primera Divi UNSPECIFIED TRUNCATE 156 ``` # SVL\$1STATEMENTTEXT SVL\$1STATEMENTTEXT Utilice la vista SVL\$1STATEMENTTEXT para obtener un registro completo de todos los comandos SQL que se ejecutaron en el sistema. La vista SVL\$1STATEMENTTEXT tiene la unión de todas las filas en las tablas [STL\$1DDLTEXT](r_STL_DDLTEXT.md), [STL\$1QUERYTEXT](r_STL_QUERYTEXT.md) y [STL\$1UTILITYTEXT](r_STL_UTILITYTEXT.md). Esta vista también incluye una combinación con la tabla STL\$1QUERY. SVL\$1STATEMENTTEXT 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_STATEMENTTEXT.html) ## Consulta de ejemplo Consulta de ejemplo En la siguiente consulta, se devuelven instrucciones DDL que se ejecutaron el 16 de junio de 2009: ``` select starttime, type, rtrim(text) from svl_statementtext where starttime like '2009-06-16%' and type='DDL' order by starttime asc; starttime | type | rtrim ---------------------------|------|-------------------------------- 2009-06-16 10:36:50.625097 | DDL | create table ddltest(c1 int); 2009-06-16 15:02:16.006341 | DDL | drop view alltickitjoin; 2009-06-16 15:02:23.65285 | DDL | drop table sales; 2009-06-16 15:02:24.548928 | DDL | drop table listing; 2009-06-16 15:02:25.536655 | DDL | drop table event; ... ``` ### Reconstruyendo el SQL almacenado Reconstruyendo el SQL almacenado Para reconstruir el SQL almacenado en la columna `text` de SVL\$1STATEMENTTEXT, ejecute una instrucción SELECT para crear SQL desde 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 SVL_STATEMENTTEXT where pid=pg_backend_pid(); ``` 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 VL\$1STATEMENTTEXT. ``` 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 VL\$1STATEMENTTEXT. ``` select sequence, text from SVL_STATEMENTTEXT where pid = pg_backend_pid() order by starttime, sequence; ``` ``` sequence | text ----------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 0 | select\n1 AS a0123456789012345678901234567890123456789012345678901234567890,\n2 AS b0123456789012345678901234567890123456789012345678901234567890,\n3 AS b012345678901234567890123456789012345678901234 1 | \nFROM stl_querytext; ``` Para reconstruir el SQL almacenado en VL\$1STATEMENTTEXT, 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 SVL_STATEMENTTEXT where pid=pg_backend_pid(); ``` 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; ``` # SVL\$1STORED\$1PROC\$1CALL SVL\$1STORED\$1PROC\$1CALL Puede consultar la vista de sistema SVL\$1STORED\$1PROC\$1CALL para obtener información acerca de las llamadas de procedimientos almacenados, incluidos la hora de inicio, la hora de finalización y si se canceló una llamada. Cada llamada de procedimiento almacenado recibe un ID de consulta. SVL\$1STORED\$1PROC\$1CALL es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1PROCEDURE\$1CALL](SYS_PROCEDURE_CALL.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_STORED_PROC_CALL.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta devuelve el tiempo transcurrido en orden descendente y el estado de finalización de las llamadas del procedimiento almacenado correspondientes al último día. ``` select query, datediff(seconds, starttime, endtime) as elapsed_time, aborted, trim(querytxt) as call from svl_stored_proc_call where starttime >= getdate() - interval '1 day' order by 2 desc; query | elapsed_time | aborted | call --------+--------------+---------+----------------------------------------------------------------------------------- 4166 | 7 | 0 | call search_batch_status(35,'succeeded'); 2433 | 3 | 0 | call test_batch (123456) 1810 | 1 | 0 | call prod_benchmark (123456) 1836 | 1 | 0 | call prod_testing (123456) 1808 | 1 | 0 | call prod_portfolio ('N', 123456) 1816 | 1 | 1 | call prod_portfolio ('Y', 123456) ``` # SVL\$1STORED\$1PROC\$1MESSAGES SVL\$1STORED\$1PROC\$1MESSAGES Puede consultar la vista del sistema SVL\$1STORED\$1PROC\$1MESSAGES para obtener información sobre los mensajes de procedimientos almacenados. Los mensajes generados se registran incluso si se cancela la llamada al procedimiento almacenado. Cada llamada de procedimiento almacenado recibe un ID de consulta. Para obtener más información acerca de cómo establecer el nivel mínimo de mensajes registrados, consulte stored\$1proc\$1log\$1min\$1messages. SVL\$1STORED\$1PROC\$1MESSAGES es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver sus datos. Para obtener más información, consulte [Visibilidad de datos en las tablas y vistas de sistema](cm_chap_system-tables.md#c_visibility-of-data). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1PROCEDURE\$1MESSAGES](SYS_PROCEDURE_MESSAGES.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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_STORED_PROC_MESSAGES.html) ## Consulta de ejemplo Consulta de ejemplo Las siguientes instrucciones SQL muestran cómo utilizar SVL\$1STORED\$1PROC\$1MESSAGES para revisar los mensajes generados. ``` -- Create and run a stored procedure CREATE OR REPLACE PROCEDURE test_proc1(f1 int) AS $$ BEGIN RAISE INFO 'Log Level: Input f1 is %',f1; RAISE NOTICE 'Notice Level: Input f1 is %',f1; EXECUTE 'select invalid'; RAISE NOTICE 'Should not print this'; EXCEPTION WHEN OTHERS THEN raise exception 'EXCEPTION level: Exception Handling'; END; $$ LANGUAGE plpgsql; -- Call this stored procedure CALL test_proc1(2); -- Show raised messages with level higher than INFO SELECT query, recordtime, loglevel, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages WHERE loglevel > 30 AND query = 193 ORDER BY recordtime; query | recordtime | loglevel | loglevel_text | message | aborted -------+----------------------------+----------+---------------+-------------------------------------+--------- 193 | 2020-03-17 23:57:18.277196 | 40 | NOTICE | Notice Level: Input f1 is 2 | 1 193 | 2020-03-17 23:57:18.277987 | 60 | EXCEPTION | EXCEPTION level: Exception Handling | 1 (2 rows) -- Show raised messages at EXCEPTION level SELECT query, recordtime, loglevel, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages WHERE loglevel_text = 'EXCEPTION' AND query = 193 ORDER BY recordtime; query | recordtime | loglevel | loglevel_text | message | aborted -------+----------------------------+----------+---------------+-------------------------------------+--------- 193 | 2020-03-17 23:57:18.277987 | 60 | EXCEPTION | EXCEPTION level: Exception Handling | 1 ``` Las siguientes instrucciones SQL muestran cómo utilizar SVL\$1STORED\$1PROC\$1MESSAGES para revisar los mensajes generados con la opción SET cuando se crea un procedimiento almacenado. Como test\$1proc() tiene el nivel de registro mínimo de NOTICE, solo los mensajes de nivel NOTICE, WARNING y EXCEPTION se registran en SVL\$1STORED\$1PROC\$1MESSAGES. ``` -- Create a stored procedure with minimum log level of NOTICE CREATE OR REPLACE PROCEDURE test_proc() AS $$ BEGIN RAISE LOG 'Raise LOG messages'; RAISE INFO 'Raise INFO messages'; RAISE NOTICE 'Raise NOTICE messages'; RAISE WARNING 'Raise WARNING messages'; RAISE EXCEPTION 'Raise EXCEPTION messages'; RAISE WARNING 'Raise WARNING messages again'; -- not reachable END; $$ LANGUAGE plpgsql SET stored_proc_log_min_messages = NOTICE; -- Call this stored procedure CALL test_proc(); -- Show the raised messages SELECT query, recordtime, loglevel_text, trim(message) as message, aborted FROM svl_stored_proc_messages WHERE query = 149 ORDER BY recordtime; query | recordtime | loglevel_text | message | aborted -------+----------------------------+---------------+--------------------------+--------- 149 | 2020-03-16 21:51:54.847627 | NOTICE | Raise NOTICE messages | 1 149 | 2020-03-16 21:51:54.84766 | WARNING | Raise WARNING messages | 1 149 | 2020-03-16 21:51:54.847668 | EXCEPTION | Raise EXCEPTION messages | 1 (3 rows) ``` # SVL\$1TERMINATE SVL\$1TERMINATE Registra la hora a la que un usuario cancela o termina un proceso. SELECT PG\$1TERMINATE\$1BACKEND(*pid*), SELECT PG\$1CANCEL\$1BACKEND(*pid*) y CANCEL *pid* crea una entrada de registro en SVL\$1TERMINATE. SVL\$1TERMINATE es visible solo 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\$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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_TERMINATE.html) El siguiente comando muestra la última consulta cancelada. ``` select * from svl_terminate order by eventtime desc limit 1; pid | eventtime | userid | type ------+----------------------------+--------+-------- 8324 | 2020-03-24 09:42:07.298937 | 1 | CANCEL (1 row) ``` # SVL\$1UDF\$1LOG SVL\$1UDF\$1LOG Registra los mensajes de error y advertencia definidos por el sistema que se generan durante la ejecución de la función definida por el usuario (UDF). SVL\$1UDF\$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). Algunos o todos los datos de esta tabla también están en la vista de monitoreo SYS [SYS\$1UDF\$1LOG](SYS_UDF_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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_UDF_LOG.html) ## Consultas de ejemplo Consultas de ejemplo En el siguiente ejemplo, se muestra cómo las UDF administran los errores definidos por el sistema. El primer bloque muestra la definición para una función UDF que devuelve la inversa de un argumento. Cuando ejecuta la función y proporciona un argumento 0, como se muestra en el segundo bloque, la función devuelve un error. La tercera instrucción lee el mensaje de error que se registra en SVL\$1UDF\$1LOG ``` -- Create a function to find the inverse of a number CREATE OR REPLACE FUNCTION f_udf_inv(a int) RETURNS float IMMUTABLE AS $$ return 1/a $$ LANGUAGE plpythonu; -- Run the function with a 0 argument to create an error Select f_udf_inv(0) from sales; -- Query SVL_UDF_LOG to view the message Select query, created, message::varchar from svl_udf_log; query | created | message -------+----------------------------+--------------------------------------------------------- 2211 | 2015-08-22 00:11:12.04819 | ZeroDivisionError: long division or modulo by zero\nNone ``` En el siguiente ejemplo, se agrega el registro y un mensaje de advertencia a la UDF para que una operación de división en cero dé como resultado un mensaje de advertencia, en lugar de parar con un mensaje de error. ``` -- Create a function to find the inverse of a number and log a warning CREATE OR REPLACE FUNCTION f_udf_inv_log(a int) RETURNS float IMMUTABLE AS $$ import logging logger = logging.getLogger() #get root logger if a==0: logger.warning('You attempted to divide by zero.\nReturning zero instead of error.\n') return 0 else: return 1/a $$ LANGUAGE plpythonu; ``` En el siguiente ejemplo, se ejecuta la función y, luego se consulta SVL\$1UDF\$1LOG para ver el mensaje. ``` -- Run the function with a 0 argument to trigger the warning Select f_udf_inv_log(0) from sales; -- Query SVL_UDF_LOG to view the message Select query, created, message::varchar from svl_udf_log; query | created | message ------+----------------------------+---------------------------------- 0 | 2015-08-22 00:11:12.04819 | You attempted to divide by zero. Returning zero instead of error. ``` # SVL\$1USER\$1INFO SVL\$1USER\$1INFO Puede recuperar datos sobre los usuarios de la base de datos de Amazon Redshift con la vista SVL\$1USER\$1INFO. SVL\$1USER\$1INFO 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_USER_INFO.html) ## Consultas de ejemplo Consulta de ejemplo El siguiente comando recupera la información del usuario de SVL\$1USER\$1INFO. ``` SELECT * FROM SVL_USER_INFO; ``` # SVL\$1VACUUM\$1PERCENTAGE SVL\$1VACUUM\$1PERCENTAGE La vista SVL\$1VACUUM\$1PERCENTAGE informa el porcentaje de bloques de datos asignados a una tabla después de realizar una limpieza. El número de porcentaje muestra cuánto espacio en disco se reclamó. Consulte el comando [VACUUM](r_VACUUM_command.md) para obtener más información acerca de la utilidad de limpieza. Solo los superusuarios pueden ver SVL\$1VACUUM\$1PERCENTAGE. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_SVL_VACUUM_PERCENTAGE.html) ## Consulta de ejemplo Consulta de ejemplo La siguiente consulta muestra el porcentaje para una operación específica sobre la tabla 100238: ``` select * from svl_vacuum_percentage where table_id=100238 and xid=2200; xid | table_id | percentage -----+----------+------------ 1337 | 100238 | 60 (1 row) ``` Luego de la operación de limpieza, la tabla contenía un 60% de los bloques originales. # Tablas de catálogos de sistema Tablas de catálogos de sistema **Topics** + [ # PG\$1ATTRIBUTE\$1INFO ](r_PG_ATTRIBUTE_INFO.md) + [ # PG\$1CLASS\$1INFO ](r_PG_CLASS_INFO.md) + [ # PG\$1DATABASE\$1INFO ](r_PG_DATABASE_INFO.md) + [ # PG\$1DEFAULT\$1ACL ](r_PG_DEFAULT_ACL.md) + [ # PG\$1EXTERNAL\$1SCHEMA ](r_PG_EXTERNAL_SCHEMA.md) + [ # PG\$1LIBRARY ](r_PG_LIBRARY.md) + [ # PG\$1PROC\$1INFO ](r_PG_PROC_INFO.md) + [ # PG\$1STATISTIC\$1INDICATOR ](r_PG_STATISTIC_INDICATOR.md) + [ # PG\$1TABLE\$1DEF ](r_PG_TABLE_DEF.md) + [ # PG\$1USER\$1INFO ](pg_user_info.md) + [ # Consulta de las tablas de catálogos ](c_join_PG.md) Los catálogos de sistema almacenan metadatos de esquema, como información acerca de tablas y columnas. Las tablas de catálogos de sistemas tienen un prefijo PG. Los usuarios de Amazon Redshift pueden acceder a las tablas de catálogos de PostgreSQL estándar. Para obtener más información acerca de los catálogos de sistema de PostgreSQL, consulte [PostgreSQL System Tables (Tablas de sistema de PostgreSQL)](https://www.postgresql.org/docs/8.0/static/catalogs.html#CATALOGS-OVERVIEW) # PG\$1ATTRIBUTE\$1INFO PG\$1ATTRIBUTE\$1INFO PG\$1ATTRIBUTE\$1INFO es una vista de sistema de Amazon Redshift integrada a la tabla de catálogos de PostgreSQL PG\$1ATTRIBUTE y a la tabla de catálogos internos PG\$1ATTRIBUTE\$1ACL. PG\$1ATTRIBUTE\$1INFO incluye detalles sobre las columnas de una tabla o vista, incluidas las listas de control de acceso a columnas, si las hay. ## Columnas de la tabla Columnas de la tabla PG\$1ATTRIBUTE\$1INFO muestra la siguiente columna además de las columnas de PG\$1ATTRIBUTE. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_ATTRIBUTE_INFO.html) # PG\$1CLASS\$1INFO PG\$1CLASS\$1INFO PG\$1CLASS\$1INFO es una vista de sistema de Amazon Redshift integrada a las tablas de catálogos de PostgreSQL PG\$1CLASS y PG\$1CLASS\$1EXTENDED. PG\$1CLASS\$1INFO incluye detalles sobre la hora de creación y el estilo de distribución actual de la tabla. Para obtener más información, consulte [Distribución de datos para la optimización de consultas](t_Distributing_data.md). Todos los usuarios pueden ver PG\$1CLASS\$1INFO. 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 Columnas de la tabla PG\$1CLASS\$1INFO muestra las siguientes columnas además de las columnas de PG\$1CLASS. La columna `oid` en PG\$1CLASS se llama `reloid` en la tabla PG\$1CLASS\$1INFO. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_CLASS_INFO.html) La columna RELEFFECTIVEDISTSTYLE en PG\$1CLASS\$1INFO indica el estilo de distribución actual de la tabla. Si la tabla usa una distribución automática, RELEFFECTIVEDISTSTYLE es 10, 11 o 12, lo que indica que el estilo de distribución efectivo es AUTO (ALL) o AUTO (EVEN) o AUTO (KEY). Si la tabla usa distribución automática, el estilo de distribución podría inicialmente mostrar AUTO (ALL), para a continuación mostrar AUTO (EVEN) o AUTO (KEY) si se detecta que una columna puede resultar útil como clave de distribución. En la siguiente tabla, se proporciona el estilo de distribución para cada valor de la tabla RELEFFECTIVEDISTSTYLE: | RELEFFECTIVEDISTSTYLE | Estilo de distribución actual | | --- | --- | | 0 | EVEN | | 1 | KEY | | 8 | ALL | | 10 | AUTO (ALL) | | 11 | AUTO (EVEN) | | 12 | AUTO (KEY) | ## Ejemplo Ejemplo La siguiente consulta devuelve el estilo de distribución actual de las tablas del catálogo. ``` select reloid as tableid,trim(nspname) as schemaname,trim(relname) as tablename,reldiststyle,releffectivediststyle, CASE WHEN "reldiststyle" = 0 THEN 'EVEN'::text WHEN "reldiststyle" = 1 THEN 'KEY'::text WHEN "reldiststyle" = 8 THEN 'ALL'::text WHEN "releffectivediststyle" = 10 THEN 'AUTO(ALL)'::text WHEN "releffectivediststyle" = 11 THEN 'AUTO(EVEN)'::text WHEN "releffectivediststyle" = 12 THEN 'AUTO(KEY)'::text ELSE '<>'::text END as diststyle,relcreationtime from pg_class_info a left join pg_namespace b on a.relnamespace=b.oid; ``` ``` tableid | schemaname | tablename | reldiststyle | releffectivediststyle | diststyle | relcreationtime ---------+------------+-----------+--------------+-----------------------+------------+---------------------------- 3638033 | public | customer | 0 | 0 | EVEN | 2019-06-13 15:02:50.666718 3638037 | public | sales | 1 | 1 | KEY | 2019-06-13 15:03:29.595007 3638035 | public | lineitem | 8 | 8 | ALL | 2019-06-13 15:03:01.378538 3638039 | public | product | 9 | 10 | AUTO(ALL) | 2019-06-13 15:03:42.691611 3638041 | public | shipping | 9 | 11 | AUTO(EVEN) | 2019-06-13 15:03:53.69192 3638043 | public | support | 9 | 12 | AUTO(KEY) | 2019-06-13 15:03:59.120695 (6 rows) ``` # PG\$1DATABASE\$1INFO PG\$1DATABASE\$1INFO PG\$1DATABASE\$1INFO es una vista de sistema de Amazon Redshift que extiende la tabla de catálogos de PostgreSQL PG\$1DATABASE. Todos los usuarios pueden ver PG\$1DATABASE\$1INFO. ## Columnas de la tabla Columnas de la tabla PG\$1DATABASE\$1INFO contiene las siguientes columnas además de las columnas en PG\$1DATABASE. La columna `oid` en PG\$1DATABASE se llama `datid` en la tabla PG\$1DATABASE\$1INFO. Para obtener más información, consulte la [documentación de PostgreSQL](https://www.postgresql.org/docs/8.0/catalog-pg-database.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_DATABASE_INFO.html) # PG\$1DEFAULT\$1ACL PG\$1DEFAULT\$1ACL Almacena información acerca de los privilegios de acceso predeterminados. Para obtener más información acerca de los privilegios de acceso predeterminados, consulte [ALTER DEFAULT PRIVILEGES](r_ALTER_DEFAULT_PRIVILEGES.md). Todos los usuarios pueden ver PG\$1DEFAULT\$1ACL. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_DEFAULT_ACL.html) ## Ejemplo Ejemplo La siguiente consulta devuelve todos los privilegios predeterminados definidos para la base de datos. ``` select pg_get_userbyid(d.defacluser) as user, n.nspname as schema, case d.defaclobjtype when 'r' then 'tables' when 'f' then 'functions' end as object_type, array_to_string(d.defaclacl, ' + ') as default_privileges from pg_catalog.pg_default_acl d left join pg_catalog.pg_namespace n on n.oid = d.defaclnamespace; user | schema | object_type | default_privileges -------+--------+-------------+------------------------------------------------------- admin | tickit | tables | user1=r/admin + "group group1=a/admin" + user2=w/admin ``` El resultado en el ejemplo anterior muestra que para todas las tablas nuevas creadas por el usuario `admin` en el esquema `tickit`, `admin` concede los privilegios SELECT a `user1`, los privilegios INSERT a `group1` y los privilegios UPDATE a `user2`. # PG\$1EXTERNAL\$1SCHEMA PG\$1EXTERNAL\$1SCHEMA Almacena información acerca de los esquemas externos. PG\$1EXTERNAL\$1SCHEMA es visible para todos los usuarios. Los superusuarios pueden ver todas las filas; los usuarios normales solo pueden ver los metadatos a los que tienen acceso. Para obtener más información, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md). ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_EXTERNAL_SCHEMA.html) ## Ejemplo Ejemplo En el siguiente ejemplo, se muestran detalles de esquemas externos. ``` select esoid, nspname as schemaname, nspowner, esdbname as external_db, esoptions from pg_namespace a,pg_external_schema b where a.oid=b.esoid; esoid | schemaname | nspowner | external_db | esoptions -------+-----------------+----------+-------------+------------------------------------------------------------- 100134 | spectrum_schema | 100 | spectrum_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} 100135 | spectrum | 100 | spectrumdb | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} 100149 | external | 100 | external_db | {"IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"} ``` # PG\$1LIBRARY PG\$1LIBRARY Almacena información acerca de las bibliotecas definidas por el usuario. Todos los usuarios pueden ver PG\$1LIBRARY. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_LIBRARY.html) ## Ejemplo Ejemplo En el siguiente ejemplo se devuelve la información de las bibliotecas instaladas por el usuario. ``` select * from pg_library; name | language_oid | file_store_id | owner -----------+--------------+---------------+------ f_urlparse | 108254 | 2000 | 100 ``` # PG\$1PROC\$1INFO PG\$1PROC\$1INFO PG\$1PROC\$1INFO es una vista de sistema de Amazon Redshift integrada a la tabla de catálogos de PostgreSQL PG\$1PROC y a la tabla de catálogo internos PG\$1PROC\$1EXTENDED. PG\$1PROC\$1INFO incluye detalles sobre funciones y procedimientos almacenados, incluida información relacionada con argumentos de salida, si los hubiere. ## Columnas de la tabla Columnas de la tabla PG\$1PROC\$1INFO muestra las siguientes columnas además de las columnas de PG\$1PROC. La columna `oid` en PG\$1PROC se llama `prooid` en la tabla PG\$1PROC\$1INFO. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_PROC_INFO.html) Los proargnames del campo en PG\$1PROC\$1INFO contienen los nombres de todos los tipos de argumentos (incluidos OUT e INOUT), si los hubiere. # PG\$1STATISTIC\$1INDICATOR PG\$1STATISTIC\$1INDICATOR Almacena información acerca del número de filas insertadas o eliminadas desde la última vez que se ejecutó ANALYZE. La tabla PG\$1STATISTIC\$1INDICATOR se actualiza frecuentemente siguiendo las operaciones DML, por lo que las estadísticas son aproximadas. Solo los superusuarios pueden ver PG\$1STATISTIC\$1INDICATOR. 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 Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_STATISTIC_INDICATOR.html) ## Ejemplo Ejemplo En el siguiente ejemplo se devuelve la información de los cambios de la tabla desde el último ANALYZE. ``` select * from pg_statistic_indicator; stairelid | stairows | staiins | staidels ----------+----------+---------+--------- 108271 | 11 | 0 | 0 108275 | 365 | 0 | 0 108278 | 8798 | 0 | 0 108280 | 91865 | 0 | 100632 108267 | 89981 | 49990 | 9999 108269 | 808 | 606 | 374 108282 | 152220 | 76110 | 248566 ``` # PG\$1TABLE\$1DEF PG\$1TABLE\$1DEF Almacena información acerca de las columnas de la tabla. PG\$1TABLE\$1DEF solo devuelve información acerca de las tablas que son visibles para el usuario. Si PG\$1TABLE\$1DEF no devuelve los resultados esperados, verifique que el parámetro [search\$1path](r_search_path.md) se estableció correctamente para incluir los esquemas relevantes. Puede utilizar [SVV\$1TABLE\$1INFO](r_SVV_TABLE_INFO.md) para consultar información más exhaustiva acerca de una tabla, incluidos el sesgo de distribución de datos, el sesgo de distribución de claves, el tamaño de tabla y las estadísticas. ## Columnas de la tabla Columnas de la tabla [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/r_PG_TABLE_DEF.html) ## Ejemplo Ejemplo En el siguiente ejemplo se muestran las columnas con clave de ordenación compuesta para la tabla LINEORDER\$1COMPOUND. ``` select "column", type, encoding, distkey, sortkey, "notnull" from pg_table_def where tablename = 'lineorder_compound' and sortkey <> 0; column | type | encoding | distkey | sortkey | notnull -------------+---------+----------+---------+---------+-------- lo_orderkey | integer | delta32k | false | 1 | true lo_custkey | integer | none | false | 2 | true lo_partkey | integer | none | true | 3 | true lo_suppkey | integer | delta32k | false | 4 | true lo_orderdate | integer | delta | false | 5 | true (5 rows) ``` En el siguiente ejemplo se muestran las columnas con clave de ordenación intercalada para la tabla LINEORDER\$1INTERLEAVED. ``` select "column", type, encoding, distkey, sortkey, "notnull" from pg_table_def where tablename = 'lineorder_interleaved' and sortkey <> 0; column | type | encoding | distkey | sortkey | notnull -------------+---------+----------+---------+---------+-------- lo_orderkey | integer | delta32k | false | -1 | true lo_custkey | integer | none | false | 2 | true lo_partkey | integer | none | true | -3 | true lo_suppkey | integer | delta32k | false | 4 | true lo_orderdate | integer | delta | false | -5 | true (5 rows) ``` PG\$1TABLE\$1DEF solo devolverá información de las tablas en los esquemas que están incluidos en la ruta de búsqueda. Para obtener más información, consulte [search\$1path](r_search_path.md). Por ejemplo, suponga que crea un esquema y una tabla nuevos, luego consulta PG\$1TABLE\$1DEF. ``` create schema demo; create table demo.demotable (one int); select * from pg_table_def where tablename = 'demotable'; schemaname|tablename|column| type | encoding | distkey | sortkey | notnull ----------+---------+------+------+----------+---------+---------+-------- ``` La consulta no devuelve filas para la nueva tabla. Analice la configuración de la `search_path`. ``` show search_path; search_path --------------- $user, public (1 row) ``` Agregue el esquema `demo` a la ruta de búsqueda y ejecute la consulta de nuevo. ``` set search_path to '$user', 'public', 'demo'; select * from pg_table_def where tablename = 'demotable'; schemaname| tablename |column| type | encoding |distkey|sortkey| notnull ----------+-----------+------+---------+----------+-------+-------+-------- demo | demotable | one | integer | none | f | 0 | f (1 row) ``` # PG\$1USER\$1INFO PG\$1USER\$1INFO PG\$1USER\$1INFO es una vista del sistema de Amazon Redshift que muestra información del usuario, como el ID de usuario y el tiempo de caducidad de la contraseña. Solo los superusuarios pueden ver PG\$1USER\$1INFO. ## Columnas de la tabla Columnas de la tabla PG\$1USER\$1INFO contiene las siguientes columnas. Para obtener más información, consulte la [documentación de PostgreSQL](https://www.postgresql.org/docs/8.0/view-pg-user.html). [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/pg_user_info.html) # Consulta de las tablas de catálogos Consulta de las tablas de catálogos **Topics** + [ # Ejemplos de consultas de catálogo ](c_join_PG_examples.md) En general, puede combinar las tablas y las vistas de catálogos (relaciones cuyos nombres comienzan con **PG\$1**) con las tablas y las vistas de Amazon Redshift. Las tablas de catálogos utilizan una serie de tipos de datos que Amazon Redshift no admite. Los siguientes tipos de datos se admiten cuando las consultas combinan las tablas de catálogos a las tablas de Amazon Redshift: + bool + "char" + float4 + int2 + int4 + int8 + nombre + oid + texto + varchar Si escribe una consulta combinada que explícita o implícitamente hace referencia a una columna que tiene un tipo de datos no admitidos, la consulta devuelve un error. Las funciones SQL que se utilizan en algunas de las tablas de catálogos tampoco se admiten, a excepción de aquellas utilizadas por las tablas PG\$1SETTINGS y PG\$1LOCKS. Por ejemplo, la tabla PG\$1STATS no puede consultarse en una combinación con una tabla de Amazon Redshift debido a las funciones no admitidas. Las siguientes tablas y vistas de catálogos proporcionan información útil que se puede combinar a la información de las tablas de Amazon Redshift. Algunas de estas tablas permiten solo un acceso parcial debido a las restricciones de funciones y tipo de datos. Cuando consulte las tablas parcialmente accesibles, seleccione o consulte sus columnas con precaución. Las siguientes tablas son completamente accesibles y no contienen tipos o funciones no admitidos: + [pg\$1attribute](https://www.postgresql.org/docs/8.0/static/catalog-pg-attribute.html) + [pg\$1cast ](https://www.postgresql.org/docs/8.0/static/catalog-pg-cast.html) + [pg\$1depend](https://www.postgresql.org/docs/8.0/static/catalog-pg-depend.html) + [pg\$1description ](https://www.postgresql.org/docs/8.0/static/catalog-pg-description.html) + [pg\$1locks ](https://www.postgresql.org/docs/8.0/static/view-pg-locks.html) + [pg\$1opclass ](https://www.postgresql.org/docs/8.0/static/catalog-pg-opclass.html) Las siguientes tablas son parcialmente accesibles y contienen algunos tipos, funciones y columnas de texto truncado no admitidos. Los valores en las columnas de textos se truncan en los valores varchar(256). + [pg\$1class](https://www.postgresql.org/docs/8.0/static/catalog-pg-class.html) + [pg\$1constraint](https://www.postgresql.org/docs/8.0/static/catalog-pg-constraint.html) + [pg\$1database](https://www.postgresql.org/docs/8.0/static/catalog-pg-database.html) + [pg\$1group](https://www.postgresql.org/docs/8.0/static/catalog-pg-group.html) + [pg\$1language ](https://www.postgresql.org/docs/8.0/static/catalog-pg-language.html) + [pg\$1namespace](https://www.postgresql.org/docs/8.0/static/catalog-pg-namespace.html) + [pg\$1operator](https://www.postgresql.org/docs/8.0/static/catalog-pg-operator.html) + [pg\$1proc](https://www.postgresql.org/docs/8.0/static/catalog-pg-proc.html) + [pg\$1settings](https://www.postgresql.org/docs/8.0/static/view-pg-settings.html) + [pg\$1statistic](https://www.postgresql.org/docs/8.0/static/catalog-pg-statistic.html) + [pg\$1tables](https://www.postgresql.org/docs/8.0/static/view-pg-tables.html) + [pg\$1type ](https://www.postgresql.org/docs/8.0/static/catalog-pg-type.html) + [pg\$1user](https://www.postgresql.org/docs/8.0/static/view-pg-user.html) + [pg\$1views](https://www.postgresql.org/docs/8.0/static/view-pg-views.html) Las tablas de catálogos que no se mencionan aquí son inaccesibles o probablemente no sean de utilidad para los administradores de Amazon Redshift. Sin embargo, puede consultar cualquier tabla o vista de catálogos abiertamente si la consulta no incluye una combinación con una tabla de Amazon Redshift. Puede utilizar las columnas OID en las tablas de catálogos Postgres como columnas de combinación. Por ejemplo, la condición de combinación `pg_database.oid = stv_tbl_perm.db_id` une el ID de objeto de la base de datos interna para cada fila de PG\$1DATABASE con la columna DB\$1ID visible en la tabla STV\$1TBL\$1PERM. Las columnas OID son claves primarias internas que no están visibles cuando selecciona desde la tabla. Las vistas de catálogo no tienen columnas OID. Algunas funciones de Amazon Redshift deben ejecutarse solo en los nodos informáticos. Si una consulta hace referencia a una tabla creada por el usuario, el código SQL se ejecuta en los nodos de computación. Una consulta que utiliza como referencia solamente tablas de catálogos (tablas con un prefijo PG, como por ejemplo PG\$1TABLE\$1DEF) o que no utiliza ninguna tabla se ejecuta únicamente en el nodo principal. Si una consulta que utiliza una función de nodo informático no referencia una tabla definida por el usuario o una tabla del sistema de Amazon Redshift, devuelve el siguiente error. ``` [Amazon](500310) Invalid operation: One or more of the used functions must be applied on at least one user created table. ``` # Ejemplos de consultas de catálogo Ejemplos de consultas de catálogo En las siguientes consultas, se muestran algunas de las formas en las que puede consultar las tablas de catálogos para obtener información útil sobre una base de datos de Amazon Redshift. ## Vista del ID de la tabla, el nombre de la base de datos, los nombre del esquema y de la tabla La siguiente definición de vista combina la tabla de sistema STV\$1TBL\$1PERM con las tablas de catálogos de sistemas PG\$1CLASS, PG\$1NAMESPACE y PG\$1DATABASE para devolver el ID de la tabla, el nombre de la base de datos y los nombres del esquema y de la tabla. ``` create view tables_vw as select distinct(stv_tbl_perm.id) table_id ,trim(pg_database.datname) db_name ,trim(pg_namespace.nspname) schema_name ,trim(pg_class.relname) table_name from stv_tbl_perm join pg_class on pg_class.oid = stv_tbl_perm.id join pg_namespace on pg_namespace.oid = pg_class.relnamespace join pg_database on pg_database.oid = stv_tbl_perm.db_id; ``` En el siguiente ejemplo se devuelve la información para el ID de tabla 117855. ``` select * from tables_vw where table_id = 117855; ``` ``` table_id | db_name | schema_name | table_name ---------+-----------+-------------+----------- 117855 | dev | public | customer ``` ## Cómo mostrar el número de columnas por tabla de Amazon Redshift Cómo mostrar el número de columnas por tabla de Amazon Redshift La siguiente consulta combina algunas tablas de catálogos para averiguar cuántas columnas contiene cada tabla de Amazon Redshift. Los nombres de tabla de Amazon Redshift se almacenan en PG\$1TABLES y STV\$1TBL\$1PERM; siempre que sea posible, utilice PG\$1TABLES para devolver nombres de tablas de Amazon Redshift. Esta consulta no incluye tablas de Amazon Redshift. ``` select nspname, relname, max(attnum) as num_cols from pg_attribute a, pg_namespace n, pg_class c where n.oid = c.relnamespace and a.attrelid = c.oid and c.relname not like '%pkey' and n.nspname not like 'pg%' and n.nspname not like 'information%' group by 1, 2 order by 1, 2; nspname | relname | num_cols --------+----------+---------- public | category | 4 public | date | 8 public | event | 6 public | listing | 8 public | sales | 10 public | users | 18 public | venue | 5 (7 rows) ``` ## Cómo mostrar los esquemas y las tablas en una base de datos Cómo mostrar los esquemas y las tablas en una base de datos La siguiente consulta combina STV\$1TBL\$1PERM con algunas tablas PG para devolver una lista de tablas en la base de datos TICKIT y sus nombres de esquema (columna NSPNAME). La consulta también devuelve el número total de filas en cada tabla. (Esta consulta es útil cuando varios esquemas en su sistema tienen los mismos nombres de tablas). ``` select datname, nspname, relname, sum(rows) as rows from pg_class, pg_namespace, pg_database, stv_tbl_perm where pg_namespace.oid = relnamespace and pg_class.oid = stv_tbl_perm.id and pg_database.oid = stv_tbl_perm.db_id and datname ='tickit' group by datname, nspname, relname order by datname, nspname, relname; datname | nspname | relname | rows --------+---------+----------+-------- tickit | public | category | 11 tickit | public | date | 365 tickit | public | event | 8798 tickit | public | listing | 192497 tickit | public | sales | 172456 tickit | public | users | 49990 tickit | public | venue | 202 (7 rows) ``` ## Cómo mostrar los ID de tablas, los tipos de datos y los nombres de las columnas y de las tablas Cómo mostrar los ID de tablas, los tipos de datos y los nombres de las columnas y de las tablas En la siguiente consulta se muestra información acerca de cada tabla de usuario y sus columnas: el ID de tabla, el nombre de la tabla, los nombres de sus columnas y el tipo de datos de cada columna: ``` select distinct attrelid, rtrim(name), attname, typname from pg_attribute a, pg_type t, stv_tbl_perm p where t.oid=a.atttypid and a.attrelid=p.id and a.attrelid between 100100 and 110000 and typname not in('oid','xid','tid','cid') order by a.attrelid asc, typname, attname; attrelid | rtrim | attname | typname ---------+----------+----------------+----------- 100133 | users | likebroadway | bool 100133 | users | likeclassical | bool 100133 | users | likeconcerts | bool ... 100137 | venue | venuestate | bpchar 100137 | venue | venueid | int2 100137 | venue | venueseats | int4 100137 | venue | venuecity | varchar ... ``` ## Cómo contar el número de bloques de datos por cada columna en una tabla Cómo contar el número de bloques de datos por cada columna en una tabla La siguiente consulta combina la tabla STV\$1BLOCKLIST a PG\$1CLASS para devolver información de almacenamiento de las columnas en la tabla SALES. ``` select col, count(*) from stv_blocklist s, pg_class p where s.tbl=p.oid and relname='sales' group by col order by col; col | count ----+------- 0 | 4 1 | 4 2 | 4 3 | 4 4 | 4 5 | 4 6 | 4 7 | 4 8 | 4 9 | 8 10 | 4 12 | 4 13 | 8 (13 rows) ```