Categoría: Monitoreo y mantenimiento SQL
dm_exec_procedure_stats en SQL Server
El mundo del análisis de rendimiento de bases de datos puede parecer un laberinto complejo y desalentador, especialmente cuando se trata de entender cómo las consultas SQL interactúan con el sistema. Sin embargo, una herramienta poderosa que los administradores de bases de datos (DBAs) tienen a su disposición es la vista de administración dinámica (DMV) sys.dm_exec_procedure_stats
en SQL Server. En este artículo, exploraremos cómo utilizar la consulta SELECT *, LEN(plan_handle) FROM sys.dm_exec_procedure_stats
para obtener información valiosa sobre el rendimiento de los procedimientos almacenados en tu base de datos. Desglosaremos cada componente de la consulta, explicaremos su utilidad y proporcionaremos ejemplos prácticos para ilustrar su aplicación en el mundo real.
¿Qué es dm_exec_procedure_stats
?
Antes de profundizar en la consulta, es crucial entender qué es sys.dm_exec_procedure_stats
. Esta vista de administración dinámica proporciona estadísticas agregadas sobre el rendimiento de los procedimientos almacenados desde la última vez que el SQL Server se inició. Incluye métricas como el número de ejecuciones, el tiempo de CPU utilizado, el tiempo total de ejecución, entre otros datos esenciales.
Ventajas de Utilizar dm_exec_procedure_stats
- Identificación de Cuellos de Botella: Puedes identificar qué procedimientos almacenados consumen más recursos y están afectando el rendimiento general del sistema.
- Optimización de Consultas: Al conocer el rendimiento de los procedimientos almacenados, puedes enfocarte en optimizar aquellos que tienen un mayor impacto.
- Monitoreo de Uso: Esta vista te permite monitorear con qué frecuencia se ejecutan los procedimientos almacenados, ayudándote a entender su uso y relevancia en tu sistema.
Desglosando la Consulta: SELECT *, LEN(plan_handle) FROM dm_exec_procedure_stats
SELECT *
: Recuperando Toda la Información Disponible
La cláusula SELECT *
en SQL se utiliza para seleccionar todas las columnas de una tabla o vista. En el contexto de sys.dm_exec_procedure_stats
, esto significa que estamos recuperando todas las estadísticas disponibles para cada procedimiento almacenado. Algunas de las columnas más importantes incluyen:
database_id
: El ID de la base de datos donde se encuentra el procedimiento.object_id
: El ID del objeto del procedimiento almacenado.type
: El tipo de objeto (en este caso, procedimientos almacenados).cached_time
: El momento en que el plan de ejecución fue almacenado en caché.execution_count
: El número de veces que el procedimiento ha sido ejecutado.total_worker_time
: El tiempo total de CPU utilizado por todas las ejecuciones del procedimiento.total_elapsed_time
: El tiempo total transcurrido para todas las ejecuciones del procedimiento.
LEN(plan_handle)
: Midiendo la Longitud del Plan de Ejecución
La función LEN
en SQL Server devuelve la longitud de una cadena. En esta consulta, LEN(plan_handle)
mide la longitud del identificador del plan de ejecución del procedimiento almacenado. El plan_handle
es una representación hexadecimal única del plan de ejecución en caché de un procedimiento. Aunque la longitud del plan_handle
en sí puede no ser particularmente informativa, incluir esta métrica en nuestra consulta puede servir para diversos fines, como verificar la presencia de valores y entender la estructura de los datos recuperados.
¿Por Qué Incluir LEN(plan_handle)
?
Incluir LEN(plan_handle)
en nuestra consulta puede parecer trivial, pero tiene sus ventajas:
- Verificación de Datos: Nos ayuda a asegurarnos de que el
plan_handle
está presente y correctamente formateado. - Filtrado Adicional: Puede usarse en consultas más complejas donde necesitemos filtrar o agrupar datos basados en la longitud del
plan_handle
.
Ejemplo Práctico: Analizando el Rendimiento de Procedimientos Almacenados
Para ilustrar cómo se puede usar esta consulta en un escenario real, consideremos el siguiente ejemplo. Supongamos que eres un DBA y necesitas identificar qué procedimientos almacenados están consumiendo más recursos en tu base de datos. Utilizarás la consulta SELECT *, LEN(plan_handle) FROM sys.dm_exec_procedure_stats
para obtener una visión general de las estadísticas de rendimiento.
Paso 1: Ejecutar la Consulta Básica
SELECT *, LEN(plan_handle) AS plan_handle_length
FROM sys.dm_exec_procedure_stats;
Paso 2: Analizar los Resultados
Al ejecutar esta consulta, obtendrás una tabla con todas las estadísticas de los procedimientos almacenados. Algunas columnas clave en los resultados serán execution_count
, total_worker_time
, y total_elapsed_time
.
Paso 3: Identificar Procedimientos Almacenados de Alto Impacto
Para enfocarte en los procedimientos que consumen más recursos, puedes ordenar los resultados por total_worker_time
o total_elapsed_time
:
SELECT *, LEN(plan_handle) AS plan_handle_length
FROM sys.dm_exec_procedure_stats
ORDER BY total_worker_time DESC;
Este ordenamiento te permitirá identificar rápidamente cuáles son los procedimientos que más tiempo de CPU consumen. Una vez identificados, puedes profundizar en su análisis para buscar oportunidades de optimización.
Consejos de Optimización Basados en los Resultados
Columnas Clave en sys.dm_exec_procedure_stats
database_id
:- Descripción: El ID de la base de datos donde se encuentra el procedimiento almacenado.
- Importancia: Permite identificar en qué base de datos se están ejecutando los procedimientos, útil para entornos con múltiples bases de datos.
object_id
:- Descripción: El ID del objeto del procedimiento almacenado.
- Importancia: Identifica específicamente qué procedimiento almacenado está siendo evaluado.
type
:- Descripción: El tipo de objeto (normalmente ‘P’ para procedimientos almacenados).
- Importancia: Confirma que el objeto analizado es un procedimiento almacenado.
cached_time
:- Descripción: El momento en que el plan de ejecución fue almacenado en caché.
- Importancia: Ayuda a entender cuándo se almacenó el plan de ejecución, lo que puede influir en la interpretación de las estadísticas.
execution_count
:- Descripción: El número de veces que el procedimiento ha sido ejecutado.
- Importancia: Es fundamental para medir la frecuencia de uso de un procedimiento almacenado.
total_worker_time
:- Descripción: El tiempo total de CPU utilizado por todas las ejecuciones del procedimiento.
- Importancia: Indica la cantidad de recursos de CPU consumidos, útil para identificar procedimientos que pueden necesitar optimización.
total_elapsed_time
:- Descripción: El tiempo total transcurrido para todas las ejecuciones del procedimiento.
- Importancia: Mide el tiempo total que ha tardado en ejecutarse el procedimiento, importante para evaluar el rendimiento general.
total_logical_reads
:- Descripción: El número total de lecturas lógicas realizadas por todas las ejecuciones del procedimiento.
- Importancia: Ayuda a identificar el impacto del procedimiento en el rendimiento del sistema de E/S.
total_physical_reads
:- Descripción: El número total de lecturas físicas realizadas por todas las ejecuciones del procedimiento.
- Importancia: Informa sobre el acceso a disco, importante para entender la carga de I/O.
total_logical_writes
:- Descripción: El número total de escrituras lógicas realizadas por todas las ejecuciones del procedimiento.
- Importancia: Proporciona información sobre la cantidad de escrituras, útil para optimizar procedimientos con muchas operaciones de escritura.
total_clr_time
:- Descripción: El tiempo total de ejecución de los procedimientos CLR (Common Language Runtime).
- Importancia: Relevante si utilizas procedimientos CLR en SQL Server.
Ejemplo de Consulta Personalizada
Para centrarse en las columnas más importantes y realizar un análisis más enfocado, puedes modificar la consulta de la siguiente manera:
SELECT
database_id,
object_id,
type,
cached_time,
execution_count,
total_worker_time,
total_elapsed_time,
total_logical_reads,
total_physical_reads,
total_logical_writes,
LEN(plan_handle) AS plan_handle_length
FROM
sys.dm_exec_procedure_stats
ORDER BY
total_worker_time DESC;
Esta consulta se enfoca en las métricas clave para el análisis del rendimiento de los procedimientos almacenados, permitiéndote identificar rápidamente los procedimientos que consumen más recursos y necesitan optimización.
Optimización de Procedimientos con Alto total_worker_time
- Revisar Índices: Asegúrate de que los procedimientos almacenados estén utilizando índices adecuados para mejorar el rendimiento de las consultas.
- Refactorización de Código: Simplifica las consultas dentro de los procedimientos almacenados, eliminando operaciones innecesarias y utilizando subconsultas eficientes.
- Monitoreo Continuo: Establece un monitoreo regular de estos procedimientos para detectar y corregir problemas de rendimiento a medida que surgen.
Optimización de Procedimientos con Alto total_elapsed_time
- Paralelismo de Consultas: Considera habilitar el paralelismo en consultas que pueden beneficiarse de la ejecución concurrente.
- Optimización de I/O: Asegúrate de que las operaciones de entrada/salida (I/O) estén optimizadas, reduciendo la latencia en la ejecución de procedimientos.
Conclusión
La consulta SELECT *, LEN(plan_handle) FROM sys.dm_exec_procedure_stats
es una herramienta poderosa en el arsenal de cualquier DBA para el análisis y optimización del rendimiento de los procedimientos almacenados en SQL Server. Al entender y utilizar las estadísticas proporcionadas por sys.dm_exec_procedure_stats
, puedes identificar cuellos de botella, optimizar consultas y mejorar significativamente el rendimiento general de tu base de datos. Recuerda siempre monitorear y ajustar regularmente tus procedimientos almacenados para mantener un sistema eficiente y rápido.
¿Qué es un SGBDR SQL Server? Todo lo que Necesitas Saber
Cambiar el collation en un servidor sql server 2019
UPDATE JOIN en SQL para Actualizar Tablas Relacionadas
Top de Tablas del Sistema SQL Server más importantes
El uso de SQL Server como sistema de gestión de bases de datos relacional es una práctica común en muchas empresas y organizaciones. Uno de los aspectos fundamentales para administrar adecuadamente una base de datos en SQL Server es comprender las tablas del sistema. Estas tablas son esenciales para obtener información sobre la estructura de la base de datos, su configuración y su funcionamiento. En este blog, exploraremos las tablas del sistema más importantes en SQL Server, su propósito y cómo usarlas eficazmente.
¿Qué son las tablas del sistema en SQL Server?
Las tablas del sistema en SQL Server son un conjunto de tablas internas que el sistema utiliza para almacenar metadatos sobre la base de datos y sus componentes. Estos metadatos incluyen información sobre tablas, columnas, índices, permisos y otros elementos cruciales para el funcionamiento del sistema.
SQL Server organiza estas tablas en varios esquemas del sistema, principalmente en sys
y INFORMATION_SCHEMA
. Aunque los usuarios no deben modificar directamente estas tablas, es posible consultarlas para obtener información valiosa sobre la base de datos.
Principales tablas del sistema en el esquema sys
El esquema sys
contiene muchas tablas y vistas que proporcionan información detallada sobre la base de datos. A continuación, describimos algunas de las más importantes:
1. sys.objects
La tabla sys.objects
contiene una fila para cada objeto creado dentro de la base de datos, como tablas, vistas, procedimientos almacenados y funciones.
Ejemplo de consulta:
SELECT name, object_id, type_desc
FROM sys.objects
WHERE type = 'U'; -- U representa las tablas de usuario
Esta consulta retorna los nombres, identificadores de objeto y descripciones de tipo de todas las tablas de usuario en la base de datos.
2. sys.tables
La tabla sys.tables
es una vista que muestra una fila por cada tabla de usuario en la base de datos. Es una vista filtrada de sys.objects
.
Ejemplo de consulta:
SELECT name, create_date, modify_date
FROM sys.tables;
Esta consulta devuelve los nombres de las tablas junto con las fechas de creación y modificación.
3. sys.columns
La tabla sys.columns
contiene una fila por cada columna de cada objeto de tabla o vista en la base de datos.
Ejemplo de consulta:
SELECT table_name = t.name, column_name = c.name, c.column_id, c.data_type
FROM sys.columns c
JOIN sys.tables t ON c.object_id = t.object_id;
Esta consulta lista todas las columnas y sus tipos de datos para cada tabla en la base de datos.
4. sys.indexes
La tabla sys.indexes
almacena información sobre los índices definidos en tablas y vistas.
Ejemplo de consulta:
SELECT name, index_id, type_desc, is_unique
FROM sys.indexes
WHERE object_id = OBJECT_ID('NombreDeLaTabla');
Reemplaza NombreDeLaTabla
con el nombre de la tabla específica para obtener información sobre sus índices.
5. sys.partitions
La tabla sys.partitions
proporciona una fila por cada partición de una tabla o índice en la base de datos.
Ejemplo de consulta:
SELECT object_name(p.object_id) AS table_name, i.name AS index_name, p.partition_number, p.rows
FROM sys.partitions p
JOIN sys.indexes i ON p.object_id = i.object_id AND p.index_id = i.index_id
WHERE object_name(p.object_id) = 'NombreDeLaTabla';
Esta consulta muestra las particiones y el número de filas para una tabla específica.
Principales vistas del sistema en INFORMATION_SCHEMA
El esquema INFORMATION_SCHEMA
proporciona una forma estandarizada de obtener información sobre objetos de la base de datos. Aquí destacamos algunas vistas esenciales:
1. INFORMATION_SCHEMA.TABLES
Esta vista contiene una fila por cada tabla y vista en la base de datos.
Ejemplo de consulta:
SELECT table_name, table_type
FROM INFORMATION_SCHEMA.TABLES;
Esta consulta lista todas las tablas y vistas con sus tipos (base table o view).
2. INFORMATION_SCHEMA.COLUMNS
La vista INFORMATION_SCHEMA.COLUMNS
proporciona información sobre cada columna en cada tabla y vista de la base de datos.
Ejemplo de consulta:
SELECT table_name, column_name, data_type
FROM INFORMATION_SCHEMA.COLUMNS
WHERE table_name = 'NombreDeLaTabla';
Reemplaza NombreDeLaTabla
para obtener los detalles de las columnas de una tabla específica.
3. INFORMATION_SCHEMA.KEY_COLUMN_USAGE
Esta vista muestra información sobre las columnas que son clave primaria o clave externa.
Ejemplo de consulta:
SELECT table_name, column_name, constraint_name
FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE;
Esta consulta proporciona los nombres de tablas, columnas y restricciones relacionadas con claves primarias y externas.
4. INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE
La vista INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE
proporciona información sobre las columnas utilizadas en restricciones.
Ejemplo de consulta:
SELECT table_name, column_name, constraint_name
FROM INFORMATION_SCHEMA.CONSTRAINT_COLUMN_USAGE;
Esta consulta lista las columnas y las restricciones que las utilizan.
Uso de las tablas del sistema para optimización y administración
Las tablas del sistema no solo son útiles para obtener información sobre la estructura de la base de datos, sino que también son cruciales para la optimización y administración de la misma. Aquí hay algunos ejemplos de cómo puedes utilizarlas:
Identificación de índices no utilizados
Puedes usar sys.dm_db_index_usage_stats
junto con sys.indexes
para identificar índices que no se usan frecuentemente y que podrían eliminarse para mejorar el rendimiento.
Ejemplo de consulta:
SELECT i.name AS index_name, i.object_id, i.index_id, u.user_seeks, u.user_scans, u.user_lookups
FROM sys.indexes i
LEFT JOIN sys.dm_db_index_usage_stats u ON i.object_id = u.object_id AND i.index_id = u.index_id
WHERE i.object_id = OBJECT_ID('NombreDeLaTabla') AND u.user_seeks = 0 AND u.user_scans = 0 AND u.user_lookups = 0;
Monitorización de espacio de tabla
Puedes consultar sys.dm_db_partition_stats
para monitorizar el espacio utilizado por las tablas y los índices.
Ejemplo de consulta:
SELECT object_name(p.object_id) AS table_name, SUM(p.used_page_count) * 8 AS used_kb
FROM sys.dm_db_partition_stats p
GROUP BY object_name(p.object_id);
Esta consulta calcula el espacio utilizado en KB por cada tabla.

TOP de tablas del Sistema Importantes en SQL Server
1. sys.objects
Vista de sistema: sys.objects
Objetivo: Lista todos los objetos definidos en la base de datos, incluyendo tablas, vistas, procedimientos almacenados, funciones, etc.
2. sys.tables
Vista de sistema: sys.tables
Objetivo: Proporciona una lista de todas las tablas definidas en la base de datos.
3. sys.columns
Vista de sistema: sys.columns
Objetivo: Contiene una fila para cada columna de cada tabla o vista en la base de datos.
4. sys.indexes
Vista de sistema: sys.indexes
Objetivo: Lista todos los índices definidos en las tablas y vistas de la base de datos.
5. sys.partitions
Vista de sistema: sys.partitions
Objetivo: Proporciona información sobre las particiones de tablas e índices.
6. sys.schemas
Vista de sistema: sys.schemas
Objetivo: Lista todos los esquemas definidos en la base de datos.
7. sys.procedures
Vista de sistema: sys.procedures
Objetivo: Proporciona una lista de todos los procedimientos almacenados en la base de datos.
8. sys.views
Vista de sistema: sys.views
Objetivo: Contiene una fila para cada vista definida en la base de datos.
9. sys.triggers
Vista de sistema: sys.triggers
Objetivo: Lista todos los disparadores (triggers) definidos en las tablas y vistas.
10. sys.foreign_keys
Vista de sistema: sys.foreign_keys
Objetivo: Proporciona información sobre las claves foráneas definidas en la base de datos.
11. sys.key_constraints
Vista de sistema: sys.key_constraints
Objetivo: Lista todas las restricciones de clave primaria y única en las tablas de la base de datos.
12. sys.server_principals
Vista de sistema: sys.server_principals
Objetivo: Lista las conexiones definidas en el servidor, incluyendo logins y grupos.
13. sys.database_principals
Vista de sistema: sys.database_principals
Objetivo: Proporciona una lista de todos los usuarios y roles de la base de datos.
14. sys.sysconfigures
Vista de sistema: sys.sysconfigures
Objetivo: Contiene información sobre los parámetros de configuración del servidor.
15. sys.dm_exec_requests
Vista de sistema: sys.dm_exec_requests
Objetivo: Proporciona información sobre las solicitudes de ejecución que están en progreso en el servidor SQL.
16. sys.dm_exec_sessions
Vista de sistema: sys.dm_exec_sessions
Objetivo: Lista todas las sesiones actuales que están conectadas al servidor SQL.
17. sys.dm_tran_locks
Vista de sistema: sys.dm_tran_locks
Objetivo: Proporciona información sobre los bloqueos de transacciones en el servidor SQL.
18. sys.dm_os_wait_stats
Vista de sistema: sys.dm_os_wait_stats
Objetivo: Proporciona información sobre los tipos de esperas que se producen en el servidor SQL.
Estas tablas y vistas del sistema son cruciales para la administración y el monitoreo de bases de datos en SQL Server, proporcionando información detallada sobre la estructura de la base de datos, la configuración del servidor y las actividades de los usuarios.
Conclusión
Comprender las tablas del sistema en SQL Server es fundamental para cualquier administrador de bases de datos. Estas tablas proporcionan una visión detallada de la estructura, configuración y rendimiento de la base de datos, permitiendo una administración y optimización eficientes. Utilizando las tablas del sistema sys
y las vistas de INFORMATION_SCHEMA
, puedes obtener y analizar información crítica que te ayudará a mantener y mejorar tus bases de datos SQL Server.
Generando Script de creación de Usuarios en SQL Server
Script para saber el histórico de queries ejecutados SQL
SQL: ¿Configurar los Archivos LDF y MDF en Unidades Distintas es Importante?
UPDATE JOIN en SQL para Actualizar Tablas Relacionadas
Monitoreo y Mantenimiento SQL: Mantén Tu Base de Datos Saludable
¿Qué es el Transaction Log? La Importancia en SQL Server
Cuando comencé a trabajar con bases de datos en SQL Server, una pregunta recurrente surgía en mis conversaciones con expertos: «¿Para qué sirve el Transaction Log?». Sorprendentemente, la respuesta que recibía era casi siempre la misma: «No sé, creo que para nada». Esta respuesta no me parecía correcta. Si este archivo existía, debía tener una función importante. Peor aún, en muchos sistemas en producción, observaba un manejo incorrecto del Transaction Log, como crear trabajos específicos para truncarlo sin entender por qué crecía desproporcionadamente. Estos trabajos simplemente reducían el tamaño del archivo sin más consideración.
El Verdadero Rol del Transaction Log
A lo largo de los años, al adquirir más conocimiento, aprendí que el Transaction Log es vital para mantener un sistema de base de datos saludable. Este archivo registra todas y cada una de las transacciones que se realizan en la base de datos, asegurando las propiedades ACID (Atomicidad, Consistencia, Aislamiento y Durabilidad) de las transacciones.
Cuando se modifica un dato en la base de datos, el primer paso para confirmar la transacción es registrar los cambios en el Transaction Log. Solo después de esto se puede decir que la transacción está completada. Este proceso garantiza la durabilidad de la transacción, ya que si ocurre un problema justo después de hacer «commit», el Transaction Log es el único medio que la base de datos tiene para reproducir los cambios.
Los Peligros de Truncar el Transaction Log
Muchos desarrolladores y analistas solían truncar el Transaction Log para evitar su crecimiento excesivo. Afortunadamente, desde SQL Server 2008, estas prácticas han sido descontinuadas, obligando a un manejo más adecuado del Transaction Log. Truncar el Transaction Log y reducir su tamaño puede degradar el rendimiento del sistema, ya que ninguna transacción puede ser confirmada hasta que el log esté listo para recibir nuevas transacciones. Además, cada vez que el log crece, puede fragmentarse en el disco, afectando aún más la performance.
Manejo del Transaction Log Según el Modelo de Recuperación
El Transaction Log se gestiona según el modelo de recuperación configurado en la base de datos. En futuros posts, exploraremos en detalle estos modelos. Por ahora, es crucial entender que los registros del Transaction Log pueden estar en estado activo o inactivo, permitiendo identificar los registros que ya no son útiles y pueden ser sobrescritos. Si no hay espacio libre o registros inactivos, el log crecerá, lo cual es costoso en términos de rendimiento.
El comportamiento cíclico del Transaction Log permite que, una vez que llega al final del archivo, busque espacio libre al inicio para seguir escribiendo transacciones.
Configuración Óptima del Transaction Log
Para saber el tamaño y las propiedades de crecimiento del Transaction Log, podemos ejecutar el siguiente comando:
sqlCopiar códigoEXECUTE sp_helpfile
El resultado muestra configuraciones como «maxsize» (tamaño máximo) y «growth» (crecimiento automático). Por ejemplo, si el log está configurado para crecer un 10% cada vez que necesita más espacio, esto puede no ser óptimo. Es mejor establecer un valor fijo para el crecimiento del log, evitando un crecimiento frecuente que impacte negativamente en el rendimiento.
Escritura Secuencial del Transaction Log
Una característica clave del Transaction Log es que su método de escritura es secuencial, a diferencia de los archivos de datos que escriben de forma aleatoria según la ubicación de las páginas de datos. Esta secuencialidad permite una escritura más rápida, ya que la aguja del disco duro no necesita moverse aleatoriamente, sino que se desplaza en una dirección hasta el final del archivo antes de aplicar el comportamiento cíclico y regresar al inicio.
Prácticas Recomendadas para Manejar el Transaction Log
Para garantizar un rendimiento óptimo y una administración eficiente del Transaction Log, es crucial seguir algunas prácticas recomendadas:
1. Configurar el Tamaño Inicial Adecuado
Establezca un tamaño inicial adecuado para el Transaction Log, anticipando las necesidades de su base de datos. Esto evitará crecimientos frecuentes y mejorará la performance general del sistema.
2. Configurar el Crecimiento Automático
En lugar de permitir un crecimiento porcentual, configure el Transaction Log para que crezca en incrementos fijos. Esto proporciona un control más preciso y minimiza el impacto en el rendimiento.
ALTER DATABASE [YourDatabaseName]
MODIFY FILE (NAME = 'YourLogFileName', FILEGROWTH = 512MB);
3. Monitorizar el Transaction Log Regularmente
Use herramientas y scripts para monitorizar el tamaño y el uso del Transaction Log. Esto le ayudará a identificar patrones de uso y a ajustar configuraciones según sea necesario.
DBCC SQLPERF(LOGSPACE);
4. Realizar Copias de Seguridad del Log de Transacciones
Regularmente, haga copias de seguridad del Transaction Log. Esto no solo ayuda a mantener un tamaño manejable del log, sino que también es crucial para la recuperación de la base de datos.
BACKUP LOG [YourDatabaseName] TO DISK = 'path_to_backup_location';
5. Entender y Configurar el Modelo de Recuperación Apropiado
Elija el modelo de recuperación adecuado (Simple, Completo o Bulk-Logged) para su base de datos. Cada modelo tiene implicaciones diferentes para el Transaction Log y el proceso de recuperación.
6. Evitar el Truncamiento Manual del Transaction Log
En lugar de truncar manualmente el Transaction Log, confíe en las estrategias de copia de seguridad y en la gestión adecuada del log. El truncamiento manual puede llevar a problemas de rendimiento y pérdida de datos.
Monitoreo del Transaction Log
Monitorear el Transaction Log de SQL Server es crucial para mantener el rendimiento y la integridad de la base de datos. A continuación, se presentan varios scripts útiles para diferentes aspectos del monitoreo del Transaction Log.
1. Verificar el Uso del Transaction Log
Este script muestra el uso actual del Transaction Log de cada base de datos:
DBCC SQLPERF(LOGSPACE);
2. Consultar Información Detallada del Transaction Log
Obtenga detalles sobre el tamaño del Transaction Log, el espacio usado y otros parámetros importantes:
SELECT
db.name AS DatabaseName,
mf.name AS LogFileName,
mf.physical_name AS LogFilePath,
mf.size / 128 AS TotalSizeMB,
mf.max_size / 128 AS MaxSizeMB,
mf.growth / 128 AS GrowthMB,
ls.cntr_value / 1024 AS LogSpaceUsedMB,
(ls.cntr_value / (mf.size * 8)) * 100 AS LogSpaceUsedPercent
FROM
sys.master_files mf
JOIN
sys.databases db ON db.database_id = mf.database_id
JOIN
sys.dm_os_performance_counters ls ON ls.instance_name = db.name
WHERE
mf.type = 1 -- Log files
AND ls.counter_name = 'Log File(s) Used Size (KB)';
3. Consultar Transacciones Activas
Este script muestra información sobre las transacciones activas en el Transaction Log:
SELECT
t.database_id,
db.name AS DatabaseName,
t.transaction_id,
t.transaction_begin_time,
t.transaction_state,
t.transaction_status,
t.transaction_type,
t.transaction_uow
FROM
sys.dm_tran_database_transactions t
JOIN
sys.databases db ON t.database_id = db.database_id
WHERE
t.database_id = DB_ID('YourDatabaseName');
4. Monitorizar el Crecimiento del Transaction Log
Este script muestra eventos de crecimiento del Transaction Log:
SELECT
d.name AS DatabaseName,
mf.name AS LogFileName,
mf.physical_name AS LogFilePath,
mf.size / 128 AS CurrentSizeMB,
mf.growth / 128 AS GrowthMB,
mf.max_size / 128 AS MaxSizeMB,
mf.growth AS GrowthSetting
FROM
sys.master_files mf
JOIN
sys.databases d ON mf.database_id = d.database_id
WHERE
mf.type = 1 -- Log files
ORDER BY
d.name;
5. Consultar Fragmentación del Transaction Log
Monitorear la fragmentación del Transaction Log puede ayudar a identificar problemas de rendimiento:
SELECT
db.name AS DatabaseName,
fg.name AS FileGroupName,
df.name AS LogFileName,
df.physical_name AS LogFilePath,
df.size / 128 AS TotalSizeMB,
df.max_size / 128 AS MaxSizeMB,
df.growth / 128 AS GrowthMB,
fg.data_space_id,
fg.is_default
FROM
sys.database_files df
JOIN
sys.filegroups fg ON df.data_space_id = fg.data_space_id
JOIN
sys.databases db ON df.database_id = db.database_id
WHERE
df.type = 1 -- Log files
ORDER BY
db.name;
6. Alertas de Uso del Transaction Log
Configure alertas para cuando el uso del Transaction Log exceda un umbral especificado. Primero, cree un operador para recibir alertas:
EXEC msdb.dbo.sp_add_operator
@name=N'YourOperatorName',
@enabled=1,
@email_address=N'your-email@example.com';
Luego, cree una alerta para el uso del Transaction Log:
EXEC msdb.dbo.sp_add_alert
@name=N'Transaction Log Usage Alert',
@message_id=0,
@severity=0,
@enabled=1,
@delay_between_responses=0,
@include_event_description_in=0,
@database_name=N'YourDatabaseName',
@notification_message=N'The transaction log usage has exceeded the threshold.',
@event_description_keyword=N'',
@performance_condition=N'SQLServer:Databases|Percent Log Used|YourDatabaseName|>|80',
@job_id=N'00000000-0000-0000-0000-000000000000';
EXEC msdb.dbo.sp_add_notification
@alert_name=N'Transaction Log Usage Alert',
@operator_name=N'YourOperatorName',
@notification_method = 1;
7. Limpieza Automática del Transaction Log
Realice una copia de seguridad del Transaction Log para mantener su tamaño controlado:
sqlCopiar códigoBACKUP LOG [YourDatabaseName] TO DISK = 'path_to_backup_location';
Automatice esta tarea mediante un trabajo de SQL Server Agent:
USE msdb;
GO
EXEC dbo.sp_add_job
@job_name = N'Backup Transaction Log for YourDatabaseName';
GO
EXEC sp_add_jobstep
@job_name = N'Backup Transaction Log for YourDatabaseName',
@step_name = N'Backup Log Step',
@subsystem = N'TSQL',
@command = N'BACKUP LOG [YourDatabaseName] TO DISK = ''path_to_backup_location'';',
@retry_attempts = 5,
@retry_interval = 5;
GO
EXEC dbo.sp_add_schedule
@job_name = N'Backup Transaction Log for YourDatabaseName',
@name = N'Daily Transaction Log Backup',
@freq_type = 4,
@freq_interval = 1,
@active_start_time = 233000;
GO
EXEC sp_attach_schedule
@job_name = N'Backup Transaction Log for YourDatabaseName',
@schedule_name = N'Daily Transaction Log Backup';
GO
EXEC dbo.sp_add_jobserver
@job_name = N'Backup Transaction Log for YourDatabaseName';
GO
Estos scripts y prácticas pueden ayudar a asegurar que su Transaction Log esté monitoreado y manejado adecuadamente, contribuyendo al rendimiento y la integridad de su sistema de bases de datos SQL Server.
Conclusión
El Transaction Log es una parte fundamental de SQL Server que garantiza la integridad y durabilidad de las transacciones. Su manejo adecuado es esencial para el rendimiento y la salud de la base de datos. Al seguir prácticas recomendadas y evitar métodos obsoletos, puede asegurar que su base de datos funcione de manera eficiente y confiable.
Cambiar el collation en un servidor sql server 2019
Script Creación de Roles en SQL Server
Generando Script de creación de Usuarios en SQL Server
Qué es la temp-db en sql
Tempdb, en el mundo de la gestión de bases de datos relacionales, SQL Server de Microsoft es una de las plataformas más utilizadas. Entre sus componentes fundamentales se encuentra tempdb, una base de datos especial que desempeña un papel crucial en el rendimiento y la gestión de SQL Server. En este artículo, exploraremos en profundidad qué es tempdb, su propósito, cómo se utiliza y algunos consejos prácticos para optimizar su rendimiento.
¿Qué es tempdb?
En SQL Server que se utiliza para almacenar datos temporales, tablas temporales, variables de tabla y otros objetos temporales. A diferencia de otras bases de datos que almacenan datos permanentes, tempdb se crea cada vez que se inicia SQL Server y se elimina cuando se apaga el servidor. Esto significa que su contenido no es persistente y se utiliza principalmente para operaciones temporales durante la ejecución de consultas, procedimientos almacenados, índices y operaciones de clasificación.
Propósito de tempdb
El propósito principal de tempdb es proporcionar un espacio de trabajo temporal para almacenar datos y objetos temporales mientras se ejecutan operaciones dentro de SQL Server. Algunas de las funciones clave de tempdb incluyen:
- Tablas temporales: Utilizadas para almacenar datos temporales que solo son necesarios durante la sesión de conexión.
- Variables de tabla: Actúan como variables que almacenan conjuntos de datos temporales que pueden ser utilizados en varias operaciones dentro de una conexión.
- Almacenamiento de resultados intermedios: Durante la ejecución de consultas complejas, tempdb puede almacenar resultados intermedios y operaciones de clasificación que requieren espacio adicional.

Uso de tempdb en operaciones cotidianas
1. Creación de tablas temporales: Las tablas temporales se crean dentro de tempdb utilizando la sintaxis especial CREATE TABLE #NombreTabla
. Estas tablas son visibles solo para la sesión de conexión actual y se eliminan automáticamente cuando la conexión se cierra o se elimina explícitamente.
2. Variables de tabla: Las variables de tabla permiten almacenar conjuntos de datos temporales que pueden ser utilizados en múltiples consultas o procedimientos almacenados dentro de la misma conexión. Se declaran utilizando DECLARE @NombreVariable TABLE
.
3. Resultados intermedios y almacenamiento temporal: Durante la ejecución de consultas complejas que requieren operaciones de clasificación o agrupación, tempdb actúa como un espacio de almacenamiento temporal para almacenar resultados parciales antes de devolver el conjunto de resultados final al usuario.
Gestión y optimización de tempdb
Para garantizar un rendimiento óptimo de SQL Server, es crucial gestionar adecuadamente tempdb y optimizar su configuración. A continuación se presentan algunas estrategias clave para optimizar tempdb:
1. Tamaño y crecimiento automático: Configurar el tamaño inicial de tempdb según las necesidades del entorno y habilitar el crecimiento automático para garantizar que tempdb tenga suficiente espacio para manejar operaciones temporales sin interrupciones.
2. Colocación de archivos: Distribuir los archivos de tempdb en múltiples discos físicos para distribuir la carga de E/S y mejorar el rendimiento. Esto puede lograrse mediante la creación de múltiples archivos de datos para tempdb y asignándolos a diferentes unidades de disco.
3. Monitoreo de la actividad: Utilizar herramientas de monitoreo de SQL Server para supervisar la actividad de tempdb y identificar patrones de uso, cuellos de botella o problemas de rendimiento que puedan surgir debido a operaciones temporales intensivas.
4. Uso de instantáneas de base de datos (Database Snapshots): Al implementar instantáneas de base de datos, se puede reducir la carga de tempdb durante operaciones de copia de seguridad y restauración, ya que estas operaciones pueden ser intensivas en términos de recursos temporales.
5. Mantenimiento regular: Realizar mantenimientos regulares en tempdb, como la eliminación de objetos temporales no utilizados, la limpieza de tablas temporales y la revisión de configuraciones de almacenamiento, para mantener un rendimiento óptimo del servidor SQL.
Script 1: Obtener información general sobre tempdb
Este script te ayudará a obtener información básica sobre tempdb, incluyendo el tamaño de los archivos y el espacio utilizado.
USE tempdb;
GO
-- Obtener el tamaño actual de tempdb y espacio utilizado
SELECT
DB_NAME(database_id) AS [Database Name],
type_desc AS [File Type],
name AS [Logical Name],
size * 8 / 1024 AS [Size MB],
used_space_pages * 8 / 1024 AS [Used Space MB],
(size - used_space_pages) * 8 / 1024 AS [Free Space MB]
FROM
sys.dm_db_file_space_usage;
GO
Script 2: Monitorear actividad actual en tempdb
Este script te permite ver las sesiones y las tareas que están utilizando tempdb en el momento actual.
USE tempdb;
GO
-- Monitorear la actividad actual en tempdb
SELECT
session_id,
request_id,
user_objects_alloc_page_count,
user_objects_dealloc_page_count,
internal_objects_alloc_page_count,
internal_objects_dealloc_page_count
FROM
sys.dm_db_task_space_usage
WHERE
session_id > 50; -- Filtrar sesiones de usuario (generalmente las sesiones de sistema tienen IDs menores a 50)
GO
Script 3: Identificar objetos temporales y su uso
Este script te muestra los objetos temporales actuales en tempdb y su tamaño estimado.
USE tempdb;
GO
-- Identificar objetos temporales en tempdb
SELECT
OBJECT_NAME(object_id) AS [Object Name],
user_object_id,
type_desc AS [Type],
total_pages * 8 / 1024 AS [Size MB]
FROM
sys.dm_db_session_space_usage
WHERE
database_id = DB_ID('tempdb');
GO
Script 4: Monitorear el crecimiento de archivos de tempdb
Este script te permite verificar el crecimiento de los archivos de tempdb durante un intervalo de tiempo específico.
USE tempdb;
GO
-- Monitorear el crecimiento de archivos de tempdb
SELECT
DB_NAME(database_id) AS [Database Name],
type_desc AS [File Type],
name AS [Logical Name],
size_change_kb / 1024 AS [Size Change MB],
duration_seconds
FROM
sys.dm_io_virtual_file_stats(DB_ID('tempdb'), NULL) AS divfs
CROSS APPLY
sys.dm_io_virtual_file_stats(DB_ID('tempdb'), file_id) AS divfs2
WHERE
file_id IN (1, 2); -- Archivos de datos y de registro de tempdb respectivamente
GO
Consideraciones adicionales:
- Programación de tareas: Puedes programar estos scripts para ejecutarse periódicamente (por ejemplo, cada hora) utilizando un trabajo de SQL Server Agent para mantener un monitoreo constante.
- Análisis de tendencias: Utiliza los resultados de estos scripts para analizar las tendencias de uso de tempdb y tomar decisiones informadas sobre la capacidad y la optimización.
- Ajustes según el entorno: Asegúrate de ajustar los scripts según las configuraciones específicas de tu entorno de SQL Server.
Conclusiones
En resumen, tempdb es un componente esencial en SQL Server que proporciona un espacio de trabajo temporal para almacenar datos y objetos temporales durante la ejecución de consultas y procedimientos almacenados. Su correcta gestión y optimización son fundamentales para garantizar el rendimiento y la estabilidad de SQL Server en entornos de producción. Al comprender su propósito y aplicaciones, así como al implementar prácticas recomendadas para su configuración y mantenimiento, los administradores de bases de datos pueden maximizar la eficiencia operativa de sus sistemas SQL Server.
Cambiar el collation en un servidor sql server 2019
Descarga de SQL Server Management Studio (SSMS)
Script para saber el histórico de queries ejecutados SQL
En el mundo del desarrollo de bases de datos, la gestión y optimización de consultas SQL es una tarea fundamental para garantizar el rendimiento y la integridad de los datos. Una práctica recomendada es mantener un script histórico de las queries ejecutadas en SQL. En este artículo, exploraremos las razones por las cuales es necesario conservar este historial y cómo puede beneficiar a tu organización.
1. Auditoría y Cumplimiento
Uno de los motivos más importantes para mantener un historial de consultas SQL es la auditoría. En muchas industrias, existen regulaciones estrictas que requieren un seguimiento detallado de quién accede a la base de datos y qué acciones realizan. Un script histórico proporciona una pista de auditoría completa que puede ser invaluable durante auditorías internas y externas.
2. Resolución de Problemas
Cuando se presenta un problema en la base de datos, ya sea un error o un rendimiento lento, tener un historial de consultas ejecutadas puede ayudar a identificar rápidamente la causa. Los administradores de bases de datos pueden revisar las consultas previas para ver si hubo algún cambio significativo o una consulta ineficiente que esté afectando el rendimiento.
3. Optimización del Rendimiento
El análisis de las consultas históricas permite a los administradores identificar patrones y tendencias en el uso de la base de datos. Con esta información, pueden optimizar las consultas y mejorar el rendimiento general del sistema. Por ejemplo, si una consulta específica se ejecuta frecuentemente y tarda mucho tiempo, se pueden tomar medidas para optimizarla o ajustar los índices de la base de datos.
4. Recuperación de Datos
En situaciones donde se ha producido una pérdida de datos accidental, el historial de consultas puede ser crucial para la recuperación. Al revisar las consultas ejecutadas, es posible identificar qué datos se vieron afectados y restaurarlos a su estado original.
5. Capacitación y Mejora Continua
Para equipos de desarrollo y administración de bases de datos, el historial de consultas es una herramienta de aprendizaje. Los nuevos miembros del equipo pueden estudiar las consultas previas para entender las mejores prácticas y los estándares de la organización. Además, permite una revisión continua y mejoras en las prácticas de escritura de consultas SQL.
6. Documentación
Mantener un historial de consultas ejecutadas también sirve como documentación viva del uso de la base de datos. Esto puede ser útil no solo para los administradores, sino también para otros stakeholders que necesiten entender cómo se está utilizando la base de datos.
Script para ver el histórico de queries lanzados en sql (Insert)
select top(100)
creation_time,
last_execution_time,
execution_count,
total_worker_time/1000 as CPU,
convert(money, (total_worker_time))/(execution_count*1000)as [AvgCPUTime],
qs.total_elapsed_time/1000 as TotDuration,
convert(money, (qs.total_elapsed_time))/(execution_count*1000)as [AvgDur],
total_logical_reads as [Reads],
total_logical_writes as [Writes],
total_logical_reads+total_logical_writes as [AggIO],
convert(money, (total_logical_reads+total_logical_writes)/(execution_count + 0.0)) as [AvgIO],
[sql_handle],
plan_handle,
statement_start_offset,
statement_end_offset,
plan_generation_num,
total_physical_reads,
convert(money, total_physical_reads/(execution_count + 0.0)) as [AvgIOPhysicalReads],
convert(money, total_logical_reads/(execution_count + 0.0)) as [AvgIOLogicalReads],
convert(money, total_logical_writes/(execution_count + 0.0)) as [AvgIOLogicalWrites],
query_hash,
query_plan_hash,
total_rows,
convert(money, total_rows/(execution_count + 0.0)) as [AvgRows],
total_dop,
convert(money, total_dop/(execution_count + 0.0)) as [AvgDop],
total_grant_kb,
convert(money, total_grant_kb/(execution_count + 0.0)) as [AvgGrantKb],
total_used_grant_kb,
convert(money, total_used_grant_kb/(execution_count + 0.0)) as [AvgUsedGrantKb],
total_ideal_grant_kb,
convert(money, total_ideal_grant_kb/(execution_count + 0.0)) as [AvgIdealGrantKb],
total_reserved_threads,
convert(money, total_reserved_threads/(execution_count + 0.0)) as [AvgReservedThreads],
total_used_threads,
convert(money, total_used_threads/(execution_count + 0.0)) as [AvgUsedThreads],
case
when sql_handle IS NULL then ' '
else(substring(st.text,(qs.statement_start_offset+2)/2,(
case
when qs.statement_end_offset =-1 then len(convert(nvarchar(MAX),st.text))*2
else qs.statement_end_offset
end - qs.statement_start_offset)/2 ))
end as query_text,
db_name(st.dbid) as database_name,
object_schema_name(st.objectid, st.dbid)+'.'+object_name(st.objectid, st.dbid) as [object_name],
sp.[query_plan]
from sys.dm_exec_query_stats as qs with(readuncommitted)
cross apply sys.dm_exec_sql_text(qs.[sql_handle]) as st
cross apply sys.dm_exec_query_plan(qs.[plan_handle]) as sp
WHERE st.[text] LIKE '%insert%'
order by creation_time desc
Explicación de la Consulta anterior que muestra el histórico de queries en SQL
Consulta SQL que sirve para monitorizar y obtener estadísticas detalladas sobre consultas que contienen la palabra «INSERT«. Este tipo de análisis es fundamental para identificar y optimizar el rendimiento de las operaciones de inserción en una base de datos.

Desglose de la Consulta
Selección de los Primeros 100 Registros
TOP(100)
La consulta selecciona los primeros 100 registros de los datos que cumple con las condiciones especificadas.
Campos y Cálculos
A continuación, se seleccionan varios campos y se realizan ciertos cálculos para proporcionar métricas detalladas sobre el rendimiento de las consultas:
creation_time,
last_execution_time,
execution_count,
total_worker_time / 1000 AS CPU,
CONVERT(money, (total_worker_time)) / (execution_count * 1000) AS [AvgCPUTime],
qs.total_elapsed_time / 1000 AS TotDuration,
CONVERT(money, (qs.total_elapsed_time)) / (execution_count * 1000) AS [AvgDur],
total_logical_reads AS [Reads],
total_logical_writes AS [Writes],
total_logical_reads + total_logical_writes AS [AggIO],
CONVERT(money, (total_logical_reads + total_logical_writes) / (execution_count + 0.0)) AS [AvgIO],
[sql_handle],
plan_handle,
statement_start_offset,
statement_end_offset,
plan_generation_num,
total_physical_reads,
CONVERT(money, total_physical_reads / (execution_count + 0.0)) AS [AvgIOPhysicalReads],
CONVERT(money, total_logical_reads / (execution_count + 0.0)) AS [AvgIOLogicalReads],
CONVERT(money, total_logical_writes / (execution_count + 0.0)) AS [AvgIOLogicalWrites],
query_hash,
query_plan_hash,
total_rows,
CONVERT(money, total_rows / (execution_count + 0.0)) AS [AvgRows],
total_dop,
CONVERT(money, total_dop / (execution_count + 0.0)) AS [AvgDop],
total_grant_kb,
CONVERT(money, total_grant_kb / (execution_count + 0.0)) AS [AvgGrantKb],
total_used_grant_kb,
CONVERT(money, total_used_grant_kb / (execution_count + 0.0)) AS [AvgUsedGrantKb],
total_ideal_grant_kb,
CONVERT(money, total_ideal_grant_kb / (execution_count + 0.0)) AS [AvgIdealGrantKb],
total_reserved_threads,
CONVERT(money, total_reserved_threads / (execution_count + 0.0)) AS [AvgReservedThreads],
total_used_threads,
CONVERT(money, total_used_threads / (execution_count + 0.0)) AS [AvgUsedThreads],
Explicación de Campos Seleccionados
- creation_time: Tiempo de creación de la consulta.
- last_execution_time: Última vez que se ejecutó la consulta.
- execution_count: Número de veces que se ha ejecutado la consulta.
- total_worker_time / 1000 AS CPU: Tiempo total de CPU utilizado, convertido a segundos.
- AvgCPUTime: Tiempo promedio de CPU por ejecución.
- TotDuration: Duración total de la consulta en milisegundos.
- AvgDur: Duración promedio por ejecución.
- Reads: Lecturas lógicas totales.
- Writes: Escrituras lógicas totales.
- AggIO: I/O agregado (lecturas + escrituras).
- AvgIO: I/O promedio por ejecución.
- sql_handle, plan_handle: Identificadores de la consulta y del plan de ejecución.
- statement_start_offset, statement_end_offset: Posiciones de inicio y fin de la consulta dentro del batch.
- plan_generation_num: Número de veces que se ha generado el plan de ejecución.
- total_physical_reads: Lecturas físicas totales.
- AvgIOPhysicalReads: Lecturas físicas promedio por ejecución.
- AvgIOLogicalReads: Lecturas lógicas promedio por ejecución.
- AvgIOLogicalWrites: Escrituras lógicas promedio por ejecución.
- query_hash, query_plan_hash: Hash de la consulta y del plan de ejecución.
- total_rows: Número total de filas afectadas.
- AvgRows: Número promedio de filas por ejecución.
- total_dop: Grado total de paralelismo.
- AvgDop: Grado promedio de paralelismo.
- total_grant_kb, total_used_grant_kb, total_ideal_grant_kb: Memoria total concedida, usada e ideal en KB.
- AvgGrantKb, AvgUsedGrantKb, AvgIdealGrantKb: Promedio de memoria concedida, usada e ideal en KB por ejecución.
- total_reserved_threads, total_used_threads: Hilos totales reservados y usados.
- AvgReservedThreads, AvgUsedThreads: Hilos promedio reservados y usados por ejecución.
Texto de la Consulta y Plan de Ejecución
CASE
WHEN sql_handle IS NULL THEN ' '
ELSE SUBSTRING(st.text, (qs.statement_start_offset + 2) / 2,
(CASE
WHEN qs.statement_end_offset = -1 THEN LEN(CONVERT(nvarchar(MAX), st.text)) * 2
ELSE qs.statement_end_offset
END - qs.statement_start_offset) / 2)
END AS query_text,
DB_NAME(st.dbid) AS database_name,
OBJECT_SCHEMA_NAME(st.objectid, st.dbid) + '.' + OBJECT_NAME(st.objectid, st.dbid) AS [object_name],
sp.[query_plan]
- query_text: Extrae el texto de la consulta SQL.
- database_name: Nombre de la base de datos donde se ejecutó la consulta.
- object_name: Nombre del objeto (tabla, vista, etc.) relacionado con la consulta.
- query_plan: Plan de ejecución de la consulta.
Tablas y Funciones del Sistema
CASE
WHEN sql_handle IS NULL THEN ' '
ELSE SUBSTRING(st.text, (qs.statement_start_offset + 2) / 2,
(CASE
WHEN qs.statement_end_offset = -1 THEN LEN(CONVERT(nvarchar(MAX), st.text)) * 2
ELSE qs.statement_end_offset
END - qs.statement_start_offset) / 2)
END AS query_text,
DB_NAME(st.dbid) AS database_name,
OBJECT_SCHEMA_NAME(st.objectid, st.dbid) + '.' + OBJECT_NAME(st.objectid, st.dbid) AS [object_name],
sp.[query_plan]
- sys.dm_exec_query_stats: Vista de estadísticas de ejecución de consultas.
- sys.dm_exec_sql_text: Función que devuelve el texto completo de la consulta SQL.
- sys.dm_exec_query_plan: Función que devuelve el plan de ejecución de la consulta.
Filtrado y Orden
WHERE st.[text] LIKE '%insert%'
ORDER BY creation_time DESC;
- Filtro: Se filtran las consultas cuyo texto contiene la palabra «insert».
- Orden: Los resultados se ordenan por el tiempo de creación en orden descendente.
Esta consulta es una herramienta útil para analizar el rendimiento y el uso de recursos de las consultas SQL que contienen la palabra «insert» en su texto. Proporciona una visión detallada de cómo se comportan estas consultas en términos de CPU, duración, lecturas/escrituras y otros recursos, ayudando a los administradores de bases de datos a optimizar y solucionar problemas de rendimiento.
Script Creación de Roles en SQL Server
¿Qué hace DBCC CHECKDB?
DBCC CHECKDB
en SQL Server se utiliza para verificar la integridad física y lógica de todos los objetos en una base de datos. A continuación, se detallan sus principales funciones y lo que hace exactamente:
Funciones Principales de DBCC CHECKDB
- Comprobación de Consistencia de Datos:
- Verifica la consistencia física y lógica de las páginas de datos y las estructuras dentro de la base de datos.
- Comprueba la integridad de los índices, las claves primarias y las claves externas.
- Verificación de Asignación:
- Comprueba que todas las páginas de datos estén correctamente asignadas y que no haya páginas no asignadas que estén siendo utilizadas.
- Validación de la Estructura de Árbol de Índices:
- Asegura que las estructuras de los índices (tanto clúster como no clúster) estén correctamente organizadas y enlazadas.
- Comprobación de Consistencia de Catálogo:
- Verifica la coherencia entre los metadatos del sistema y los datos del usuario.
- Verificación de Relaciones de Claves:
- Comprueba que las relaciones de las claves externas sean válidas y consistentes.
Sintaxis Básica
DBCC CHECKDB (‘nombre_de_la_base_de_datos’)
Opciones Comunes de DBCC CHECKDB
Claro, aquí están los comandos DBCC CHECKDB en SQL Server con sus respectivas explicaciones para cada opción:
WITH NO_INFOMSGS:
- Suprime todos los mensajes informativos. Solo se mostrarán los errores.
DBCC CHECKDB ('nombre_de_la_base_de_datos') WITH NO_INFOMSGS;
WITH ALL_ERRORMSGS:
- Muestra todos los mensajes de error. Por defecto, solo se muestran los primeros 200 mensajes de error de cada tipo.
DBCC CHECKDB ('nombre_de_la_base_de_datos') WITH ALL_ERRORMSGS;
WITH TABLOCK:
- Utiliza bloqueos de tabla en lugar del método de bloqueo predeterminado. Esto puede reducir el espacio requerido en tempdb pero también puede reducir la concurrencia.
DBCC CHECKDB ('nombre_de_la_base_de_datos') WITH TABLOCK;
WITH PHYSICAL_ONLY:
- Limita la verificación a la integridad de la estructura física de la base de datos, reduciendo el tiempo de ejecución para bases de datos grandes. Esta verificación incluye la integridad de los encabezados físicos de página y registro, y la consistencia de la asignación.
DBCC CHECKDB ('nombre_de_la_base_de_datos') WITH PHYSICAL_ONLY;
REPAIR_ALLOW_DATA_LOSS, REPAIR_FAST, REPAIR_REBUILD:
Estas opciones se utilizan para reparar la base de datos. Ten en cuenta que utilizar REPAIR_ALLOW_DATA_LOSS
puede resultar en pérdida de datos, por lo que se debe usar con precaución y como último recurso.
REPAIR_ALLOW_DATA_LOSS:
- Repara la base de datos y permite la pérdida de datos.
DBCC CHECKDB ('nombre_de_la_base_de_datos', REPAIR_ALLOW_DATA_LOSS);
REPAIR_FAST:
- Mantenido por compatibilidad hacia atrás y no realiza ninguna acción de reparación.
DBCC CHECKDB ('nombre_de_la_base_de_datos', REPAIR_FAST);
REPAIR_REBUILD:
- Realiza reparaciones que no tienen riesgo de pérdida de datos, como reparar filas faltantes en índices no agrupados.
DBCC CHECKDB ('nombre_de_la_base_de_datos', REPAIR_REBUILD);
Nota: Utilizar opciones de reparación, especialmente REPAIR_ALLOW_DATA_LOSS
, puede resultar en pérdida de datos y debe usarse solo cuando sea necesario. Siempre asegúrate de tener una copia de seguridad reciente de tu base de datos antes de realizar cualquier operación de reparación.
Ejemplo de Uso
Para verificar la base de datos llamada MiBaseDeDatos
y suprimir los mensajes informativos:
DBCC CHECKDB ('MiBaseDeDatos') WITH NO_INFOMSGS;
Resultados de DBCC CHECKDB
- Mensajes de Informativos:
- Detalles sobre la verificación realizada.
- Mensajes de Error:
- Informan de cualquier inconsistencia o problema encontrado.
- Sugerencias de Reparación:
- Si se encuentran errores, se proporcionan sugerencias sobre cómo repararlos, incluyendo las opciones de reparación posibles.
Consideraciones
- Impacto en el Rendimiento:
DBCC CHECKDB
puede ser intensivo en recursos y afectar el rendimiento del servidor, especialmente en bases de datos grandes. Es recomendable ejecutarlo durante períodos de baja actividad.
- Reparación de Errores:
- La opción de reparación con pérdida de datos (
REPAIR_ALLOW_DATA_LOSS
) debe utilizarse con precaución y solo después de realizar una copia de seguridad completa.
- La opción de reparación con pérdida de datos (
DBCC CHECKDB
es una herramienta esencial para el mantenimiento y la salud de las bases de datos en SQL Server, permitiendo detectar y, en algunos casos, reparar problemas de integridad en la base de datos.
DBCC CHECKDB
verifica tanto la consistencia física como la lógica de las páginas de datos y las estructuras dentro de una base de datos en SQL Server. Aquí hay una explicación más detallada de cómo se realiza esta verificación:
Verificación de Consistencia Física cuando usas DBCC CHECKDB
La consistencia física se refiere a la integridad de las páginas de datos en el disco. DBCC CHECKDB
realiza las siguientes comprobaciones físicas:
- Integridad de Página:
- Verifica que cada página de datos en la base de datos esté correctamente estructurada y no esté dañada.
- Comprueba los encabezados de página, sumas de comprobación y otras características físicas para asegurarse de que no hay corrupción física.
- Asignación de Páginas:
- Asegura que todas las páginas de datos estén asignadas correctamente y que no haya páginas no asignadas que se estén utilizando indebidamente.
- Verifica las estructuras de asignación de páginas como el Global Allocation Map (GAM), Shared Global Allocation Map (SGAM), Page Free Space (PFS), etc.
Verificación de Consistencia Lógica cuando usas DBCC CHECKDB
La consistencia lógica se refiere a la integridad de las relaciones y estructuras lógicas dentro de la base de datos. DBCC CHECKDB
realiza las siguientes comprobaciones lógicas:
- Estructuras de Índice:
- Verifica que todos los índices, tanto clúster como no clúster, estén correctamente construidos y enlazados.
- Asegura que la estructura de los índices B-tree esté intacta.
- Relaciones de Datos:
- Comprueba las relaciones entre tablas, incluyendo claves primarias y externas, para asegurarse de que no haya datos huérfanos ni referencias rotas.
- Metadatos:
- Verifica la coherencia entre los metadatos del sistema (como el catálogo de base de datos) y los datos de usuario.
- Asegura que las definiciones de objetos en el catálogo coincidan con las estructuras reales en la base de datos.
- Restricciones de Claves:
- Asegura que todas las restricciones de claves (primarias, externas y únicas) se mantengan y que los datos respeten estas restricciones.
Proceso de DBCC CHECKDB
El proceso típico de DBCC CHECKDB
incluye las siguientes etapas:
- Comprobación de Asignación:
- Verifica la asignación de páginas y extents en la base de datos.
- Comprobación de Índices:
- Examina todos los índices en la base de datos para asegurarse de que estén en buen estado.
- Comprobación de Consistencia de Tablas:
- Verifica que todas las tablas y vistas estén lógicamente consistentes.
- Comprobación de Catálogo:
- Asegura que los metadatos del sistema sean coherentes y correctos.
Ejemplo de Uso
Aquí hay un ejemplo de cómo ejecutar DBCC CHECKDB
en una base de datos llamada MiBaseDeDatos
y suprimir los mensajes informativos:
DBCC CHECKDB (‘MiBaseDeDatos’) WITH NO_INFOMSGS;
Enlaces de interés: