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/).
# 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 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
[\[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 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
[\[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
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 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
[\[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 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
[\[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
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
[\[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
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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
**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
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
[\[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
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
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
[\[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
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
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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
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
[\[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
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
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
[\[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
```
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
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
[\[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
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
```