Cuando se trabaja con análisis de datos en SQL Server, es crucial asegurar la integridad de los datos. Un desafío común es validar el recuento de filas de una tabla entre bases de datos en diferentes instancias de SQL. En este artículo, discutiremos una tarea simple para validar el recuento de filas entre las bases de datos Publisher y Subscriber en un escenario de replicación transaccional.

Introducción

La replicación transaccional en SQL Server proporciona una opción para validar los datos en el Suscriptor con los datos en el Publicador. Esta validación se puede realizar para suscripciones específicas o para todas las suscripciones a una publicación. Sin embargo, si estás creando tu propio escenario de replicación independiente de la replicación de SQL Server, deberás implementar un proceso de validación similar para asegurarte de que tus bases de datos estén sincronizadas.

Resumen de la implementación

Para implementar el proceso de “solo recuento de filas” para comparar el número de filas entre las bases de datos Publisher y Subscriber, podemos seguir estos pasos:

1. Habilitar la opción de configuración avanzada “Ad Hoc Distributed Queries”.
2. Usar la función OPENROWSET para consultar la instancia remota de SQL.
3. Obtener el recuento de filas de las tablas en la base de datos de origen utilizando la vista del sistema sys.partitions.
4. Obtener el recuento de filas de las tablas en la base de datos remota utilizando el método OPENROWSET.
5. Unir las dos variables de tabla utilizando las columnas de esquema y nombre de tabla.
6. Comparar el número de filas entre las bases de datos de origen y destino.
7. Preparar una alerta por correo electrónico con los resultados de la comparación.

Ejemplo de código

Aquí tienes un ejemplo de código T-SQL para implementar la validación del recuento de filas:

-- Habilitar la opción "Ad Hoc Distributed Queries"
EXEC sp_configure 'show advanced options', 1
RECONFIGURE
GO
EXEC sp_configure 'ad hoc distributed queries', 1
RECONFIGURE
GO

-- Obtener el recuento de filas de las tablas en la base de datos de origen
DECLARE @SourceDatabase table (
    Instance sysname,
    DB varchar(100),
    SchemaName VARCHAR(100),
    TableName VARCHAR(100),
    Rows INT
)

INSERT INTO @SourceDatabase
SELECT
    Max(@@SERVERNAME) ServerName,
    Max(DB_NAME(DB_ID())) DatabaseName,
    sch.name AS SchemaName,
    st.Name AS TableName,
    SUM(CASE WHEN (p.index_id < 2) AND (a.type = 1) THEN p.rows ELSE 0 END) AS Rows
FROM
    sys.partitions p
    INNER JOIN sys.allocation_units a ON p.partition_id = a.container_id
    INNER JOIN sys.tables st ON st.object_id = p.object_id
    INNER JOIN sys.schemas sch ON sch.schema_id = st.schema_id
GROUP BY
    st.name,
    sch.name

-- Obtener el recuento de filas de las tablas en la base de datos remota
DECLARE @TargetDatabase table (
    Instance sysname,
    DB varchar(100),
    SchemaName VARCHAR(100),
    TableName VARCHAR(100),
    Rows INT
)

INSERT INTO @TargetDatabase
SELECT a.*
FROM OPENROWSET('SQLNCLI', 'Server=hqdbt01\SQL2017;Trusted_Connection=yes;',
    'SELECT
        Max(@@SERVERNAME) ServerName,
        Max(DB_NAME(DB_ID(''WideWorldImporters''))) DatabaseName,
        sch.name AS SchemaName,
        st.Name AS TableName,
        SUM(CASE WHEN (p.index_id < 2) AND (a.type = 1) THEN p.rows ELSE 0 END) AS Rows
    FROM
        WideWorldImporters.sys.partitions p
        INNER JOIN WideWorldImporters.sys.allocation_units a ON p.partition_id = a.container_id
        INNER JOIN WideWorldImporters.sys.tables st ON st.object_id = p.Object_ID
        INNER JOIN WideWorldImporters.sys.schemas sch ON sch.schema_id = st.schema_id
    GROUP BY
        st.name,
        sch.name') AS a;

-- Comparar el número de filas entre la base de datos de origen y destino
SELECT
    s.Instance SourceInstance,
    t.Instance TargetInstance,
    s.DB SourceDatabase,
    t.DB TargetDatabase,
    s.SchemaName SourceSchemaName,
    t.SchemaName TargetSchemaName,
    s.TableName SourceTableName,
    t.TableName TargetTableName,
    s.rows as SourceRowCount,
    t.rows as DestRowCount,
    CASE WHEN s.rows > t.rows THEN s.Rows - t.Rows ELSE t.Rows - s.Rows END 'Missing Rows',
    CASE WHEN s.rows > t.rows THEN '<=' WHEN s.Rows = t.Rows THEN '=' ELSE '=>' END 'Comparison'
FROM
    @SourceDatabase s,
    @TargetDatabase t
WHERE
    s.SchemaName = t.SchemaName
    AND s.TableName = t.TableName
    -- Descomenta la siguiente línea para excluir filas con el mismo recuento de filas
    -- AND s.rows != t.rows

Conclusión

Implementar la validación del recuento de filas en SQL Server puede ayudar a asegurar la integridad de tus datos en escenarios de replicación u cualquier otra situación donde la sincronización de datos sea crítica. Al comparar el número de filas entre bases de datos, puedes identificar rápidamente cualquier discrepancia y tomar las acciones apropiadas para resolverlas.

Aunque el código de ejemplo proporcionado aquí se centra en la validación “solo recuento de filas”, existen otros métodos y herramientas disponibles, como la utilidad tablediff o herramientas de terceros como ApexSQL Diff, que puedes explorar según tus requisitos específicos.

¿Cuáles son tus métodos favoritos para validar datos en SQL Server? ¡Comparte tus ideas en los comentarios!