Redgate Hub
Introducción
Hay varias razones por las que es posible que necesite comparar tablas o resultados.
- A veces, uno solo necesita saber si las tablas contienen datos que son iguales o diferentes; Sin detalles: solo sí o no. Esto es típico con las aserciones de prueba, donde solo necesita saber si su rutina o lote produce un resultado con los datos correctos. cuando esté provisto de valores particulares para los parámetros. Es incorrecto o correcto
- De vez en cuando, necesita saber qué filas han cambiado sin, tal vez, ser particular sobre qué columnas cambiaron y cómo.
- Hay ocasiones en las que tienes una tabla grande en términos de columnas y filas, y necesitas algo que te muestre específicamente la columna o columnas que cambiaron su valor. También es posible que desee esto al rastrear un error en una rutina que de otro modo podría requerir que pierda el tiempo escaneando ‘a ojo’.
Abordaremos estas tres tareas bastante diferentes en SQL
Si dos tablas tienen un número diferente de filas, no pueden ser lo mismo, por supuesto. Sin embargo, hay momentos en los que necesita saber si Table_B contiene todas las filas de Table_A, sin diferencias. Si desea más detalles, es posible que desee conocer las filas de la tabla que no son comunes o las filas comunes, como se indica en la clave principal, que eran diferentes. ¿Por qué limitarse a comparar solo dos mesas? Hay formas de comparar tantas como necesites. (como, por ejemplo, cuando se comparan los metadatos en varias instantáneas de bases de datos). Sí, hay muchas variaciones
Tienes herramientas y funciones para hacer esto, ¿seguro?
Siempre hay un lugar para herramientas como SQL Data Compare, TableDiff, tSQLt o Change Data Capture. Mucho depende de las circunstancias y del tipo de tarea. El problema de realizar auditorías de cambios en los datos en un sistema en vivo es un tema separado, al igual que la sincronización de tablas y bases de datos. La comparación de documentos XML también está fuera de alcance. Vamos a tratar puramente con la comparación de rutina de los datos en tablas
Es más probable que use técnicas TSQL para comparar tablas cuando:
Desarrollando Developing
En el curso del desarrollo de una base de datos, se comparan muchas tablas. No se trata solo de las grandes cosas: Cada función con valor de tabla, por ejemplo, necesita un arnés de prueba en el script de compilación que se asegure de que haga lo que cree que debe hacer en todas las circunstancias de prueba concebibles, e incorpore todos los casos extremos desagradables en los que los probadores la han capturado en el pasado. Cada procedimiento almacenado necesita una prueba para asegurarse de que el proceso que ejecuta hace exactamente lo que se pretende y nada más.
Hubo un tiempo en que la actividad de compilación era bastante pausada, pero cuando tienes una prueba de compilación e integración nocturna, lo mejor es automatizarla por completo y deshacerte de la tarea.
ETL
Cuando automatiza la carga de datos en un sistema, a menudo necesita probar varias condiciones. ¿Necesita actualizar las versiones existentes de las filas, así como insertar las nuevas? ¿Necesita una trampa para evitar entradas duplicadas o incluso eliminar entradas existentes?
Configuración de los datos de prueba.
Todos los scripts de este artículo utilizan una tabla de la base de datos de venerable PUBS. Vamos a usar la tabla de autores, pero aumentaremos el número de filas un poco a 5000 para obtener un tamaño que sea un poco más realista. He proporcionado la fuente de la tabla con el artículo.
I then created a copy of the table …
|
1
2
3
4
5
6
|
SELECT * INTO authorsCopy
FROM authors
GO
ALTER TABLE dbo.authorsCopy ADD CONSTRAINT PK_authorsCopy PRIMARY KEY CLUSTERED
(au_id) ON PRIMARY
GO
|
Y luego alteró algunas de las filas.
|
1
2
3
4
5
|
ACTUALIZACIÓN de authorsCopy CONJUNTO de direcciones=COSAS(dirección,1,1,»)
DONDE au_ID EN (
SELECT TOP 10 au_id
DE authorsCopy f
PEDIDO POR teléfono)
|
Así que ahora las dos tablas deben ser predominantemente el mismo con algunos cambios de menor importancia en el campo de dirección
Pruebas para ver si las tablas son diferentes.
A veces solo quieres saber si las tablas son las mismas. Un ejemplo de esto sería comprobar que un TVF funciona correctamente comparando su resultado con el de una tabla existente con los resultados correctos. La forma habitual de hacerlo es con el grupo de funciones CHECKSUM() en SQL Server, porque son muy rápidas.
Usando sumas de comprobación
Puede usar la función BINARY_CHECKSUM para verificar si las tablas son las mismas: bueno, aproximadamente las mismas. Es rápido, pero no es perfecto, como demostraré en un momento. Si se realiza una serie de pruebas, por ejemplo, generalmente es suficiente.
|
1
2
3
4
5
6
7
8
9
|
SI
SELECCIONE CHECKSUM_AGG(BINARY_CHECKSUM(*))
DE los autores)=(
SELECCIONE CHECKSUM_AGG(BINARY_CHECKSUM(*))
DE authorsCopy)
SELECCIONE «ellos son probablemente el mismo’
ELSE
SELECCIONE «son diferentes»
|
Para que esto funcione, la tabla no debe tener TEXT, NTEXT, IMAGE or CURSOR (o SQL_VARIANT con cualquiera de estos tipos) como su tipo base. Hoy en día, esto es cada vez más raro, pero si tiene algún tipo de complicación, puede obligar a cualquier columna con uno de los tipos no compatibles a un tipo compatible. En la práctica, generalmente uso una rutina que comprueba los metadatos y lo hace automáticamente, pero no es bonito.
En una versión de trabajo, es probable que desee especificar la lista de columnas, especialmente si tiene que hacer una coerción explícita de los tipos de datos, o si está comprobando solo ciertas columnas,
Ni BINARY_CHECKSUM() ni su hermana simple CHECKSUM() son completamente precisos para decirle si algo ha cambiado en una fila o tabla. Mostraremos esto mirando las palabras comunes del idioma inglés, contenidas en una tabla llamada CommonWords.. Esperarías que todos tuvieran una suma de verificación diferente, pero ese no es el caso.
|
1
2
3
4
5
6
7
8
9
|
SELECCIONE la cadena, BINARY_CHECKSUM(cadena) COMO «suma de verificación»
DE commonWords
DONDE BINARY_CHECKSUM(string) EN
(
SELECCIONE BINARY_CHECKSUM(cadena)
DE commonwords
GRUPO POR BINARY_CHECKSUM(cadena)
HAVING COUNT(*) > 2)
PEDIDO POR BINARY_CHECKSUM(cadena)
|
… dando el resultado …
Armado con esta información, podemos rápidamente demuestran que las diferentes cadenas pueden tener el mismo checksum
|
1
2
3
|
SELECCIONE BINARY_CHECKSUM(‘reed el nerd’),
BINARY_CHECKSUM(‘demandó el nido’),
BINARY_CHECKSUM(‘stud the oust’)
|
All these will; have the same checksum, as would …
|
1
2
3
|
SELECT
BINARY_CHECKSUM(‘accosted guards’),
BINARY_CHECKSUM(‘accorded feasts’)
|
….mientras que…
|
1
2
3
|
SELECCIONE BINARY_CHECKSUM («Esto se parece mucho a la próxima’),
BINARY_CHECKSUM («esto se parece mucho a la próxima’),
BINARY_CHECKSUM («Esto se parece mucho a la Próxima’)
|
… te da diferentes sumas de comprobación como este…
|
1
2
|
———– ———– ———–
-447523377 -447522865 -447654449
|
The sister function CHECKSUM() …
|
1
2
3
4
|
SELECT CHECKSUM(‘This looks very much como la siguiente’),
SUMA DE COMPROBACIÓN(‘esto se parece mucho a la siguiente’),
SUMA DE COMPROBACIÓN(‘Esto se parece mucho a la siguiente’)
|
finds los encuentra todos iguales, porque está utilizando la intercalación actual y mi intercalación para la base de datos no distingue mayúsculas de minúsculas. CHECKSUM() tiene como objetivo encontrar cadenas iguales en la suma de comprobación si son iguales en una comparación de cadenas.
|
1
2
|
———– ———– ———–
-943581052 -943581052 -943581052
|
Así, la mejor que se puede decir es que hay una fuerte probabilidad de que las tablas será el mismo, pero si usted necesita para estar absolutamente seguro, a continuación, utilizar otro algoritmo.
Si no le importa la diferencia en mayúsculas y minúsculas en cadenas de texto, puede usar CHECKSUM() en lugar de BINARY_CHECKSUM()
El gran valor de esta técnica es que, una vez que haya calculado la suma de verificación que necesita, puede almacenarla como un valor en la columna de una tabla en lugar de necesitar la tabla original y, por lo tanto, puede hacer que todo el proceso sea uniforme más rápido y con menos tiempo. Si está almacenando el valor de suma de comprobación devuelto por CHECKSUM() asegúrese de cotejarlo con la tabla en vivo con una suma de comprobación generada con la misma intercalación.
Aquí hay un ejemplo simple de la rutina ‘qué ha cambiado’.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
–vamos a crear un ‘checksum’ tabla ‘sobre la marcha’ mediante el SELECT INTO.
SELECCIONE
au_ID,
BINARY_CHECKSUM(au_id, au_lname, au_fname, phone, , city, , zip, ) COMO
EN auchk
DE authorscopy
ORDENAR POR au_ID
/ * ahora pondremos una restricción para comprobar que no hemos ganado la lotería (muy poco probable, pero no del todo imposible, que tengamos dos filas con la misma suma de comprobación) * /
ALTER TABLE AuChk ADD CONSTRAINT UNIQUEunique UNIQUE ()
UPDATE authorscopy SET au_fname=’Arthur’
WHERE au_ID=’327-89-2366′
SELECCIONE authorscopy.*
FROM authorscopy
INNER JOIN AuChk ON authorscopy.au_ID=AuChk.au_ID
WHERE <>BINARY_CHECKSUM(authorscopy.au_id, au_lname, au_fname, phone, , city, , zip, )
|
…which gives…
|
1
2
3
|
au_id au_lname au_fname phone address city state zip contract
———– ——— ——— ———— ————— ————- —– —– ——–
327-89-2366 Mendoza Arthur 529275-5757 15 Hague Blvd. Little Rock DE 98949 1
|
Y, a continuación, acabamos de poner en orden.
|
1
2
3
|
/* y nos acaba de pop volver a lo que era, como parte del desmontaje */
ACTUALIZACIÓN de authorscopy CONJUNTO au_fname=’Arnold’
DONDE au_ID=’327-89-2366′
|
por supuesto, usted podría utilizar un disparador, pero a veces es posible que desee simplemente un diario o semanal de informe de cambios sin la intrusión de un disparo en una tabla.
Usando XML
Una posibilidad general es comparar la versión XML de las dos tablas, ya que esto hace que el tipo de datos se traduzca en cadenas por usted. Es más lento que el enfoque de suma de comprobación, pero más confiable.
|
1
2
3
4
5
6
7
8
9
10
|
IF CONVERT(VARCHAR(MAX),(
SELECT *
FROM authors ORDER BY au_id FOR XML path, root))
=
CONVERT(VARCHAR(MAX),(
SELECT *
FROM authorscopy ORDER BY au_id FOR XMLpath, root))
SELECT ‘they are the same’
ELSE
SELECCIONE «son diferentes»
|
Aquí puede especificar el tipo de comparación mediante la especificación de la intercalación.
o puede hacer esto, comparando datos en tablas ..
|
1
2
3
4
5
6
7
8
9
10
|
IF BINARY_CHECKSUM(CONVERT(VARCHAR(MAX),(
SELECT *
FROM authors ORDER BY au_id FOR XML path, root)))
=
BINARY_CHECKSUM (CONVERT(VARCHAR(MAX),(
SELECT *
FROM authorscopy ORDER BY au_id FOR XML path, root)))
SELECCIONE «son más o menos lo mismo’
ELSE
SELECCIONE «son diferentes», SELECCIONE «son diferentes»
|
… mediante el cálculo de una suma de comprobación de la versión XML de la tabla. Esto le permite almacenar la suma de comprobación de la tabla con la que está comparando.
Encontrar dónde están las diferencias en una tabla
La tarea más simple es cuando las tablas tienen un número idéntico de filas y una estructura de tabla idéntica. A veces quieres saber qué filas son diferentes y cuáles faltan. Por supuesto, tiene que especificar lo que quiere decir con «lo mismo», especialmente si las dos tablas tienen columnas diferentes. El método que elija para hacer la comparación generalmente está determinado por estos detalles.
La UNIÓN DE TODOS GROUP AGRUPE POR técnica
El enfoque clásico para comparar tablas es usar una instrucción UNION ALL para las instrucciones SELECT que incluyen las columnas que desea comparar, y luego GROUP BY esas columnas. Obviamente, para que esto funcione, debe haber una columna con valores únicos en GROUP BY, y la clave primaria es ideal para esto. No se permiten duplicados en ninguna de las tablas. Si tienen diferentes números de filas, se mostrarán como diferencias.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
SELECT DISTINCT au_ID
DESDE el
(
SELECCIONE au_ID
DE la
(
SELECCIONE au_id, au_lname, au_fname, teléfono, dirección, ciudad, estado, código postal, contrato
DE autores
la UNIÓN de TODOS los
SELECCIONE au_id, au_lname, au_fname, teléfono, dirección, ciudad, estado, código postal, contrato
DE authorsCopy) BothOfEm
GRUPO POR au_id, au_lname, au_fname, teléfono, dirección, ciudad, estado, código postal, contrato
HAVING COUNT(*)<2) f
|
Si una de las tablas se ha duplicado, a continuación, se le dará un resultado falso, como aquí, donde se tienen dos tablas que son muy diferentes y el resultado le dice que ellos son el mismo! Por esta razón, es una buena idea incluir la(s) columna (s) que constituyen la clave primaria, ¡y solo incluir las filas una vez!
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
SELECT COUNT(*), Address_ID,TheAddress,ThePostCode
DE la
(
SELECCIONAR ID de dirección,DIRECCIÓN,Código postal
DE
(
VALORES
(9, ‘929 Augustine lane, Staple Hill Ward South Gloucestershire UK’,’BS16 4LL’),
(10, ’45 Bradfield road, Parwich Derbyshire UK’,’DE6 1QN’)
) TableA(Id de dirección,dirección,código postal)
UNION ALL
SELECCIONE Id de dirección,dirección,código postal
DE
(
VALORES
(8, «‘The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne ; Wear UK’,’NE29 7AD’),
(8, »’The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK’,’NE29 7AD’),
(9, ‘929 Augustine lane, Staple Hill Ward South Gloucestershire UK’,’BS16 4LL’),
(10, ’45 Bradfield road, Parwich Derbyshire UK’,’DE6 1QN’)
) TableB(Address_ID,TheAddress,ThePostCode)
)f
GROUP BY Address_ID,TheAddress,ThePostCode
HAVING COUNT(*)<2
|
… giving …
|
1
2
3
4
|
TheCount Address_ID TheAddress ThePostCode
———– ———– ————————- ————
(0 fila(s) afectado)
|
La técnica puede ser utilizada para la comparación de más de dos tablas. Solo necesita UNION ALL las tablas que necesita comparar y cambiar la cláusula HAVING para filtrar solo las filas que no están en todas las tablas.
Usando EXCEPTO
Ahora puede usar el mucho más limpio y ligeramente más rápido EXCEPT.
|
1
2
3
|
SELECT * from autores
EXCEPTO
SELECT * from authorsCopy
|
Esto muestra todas las filas en los autores que no se encuentran en authorsCopy. Si son el mismo, volvería sin filas
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
au_id au_lname au_fname teléfono dirección ciudad estado código postal contrato
———– ———– ——— ———— ————————– ———– —– —– ——–
041-76-1076 Sosa Sonja 000-198-8753 29 Second Avenue Omaha CT 23243 0
187-42-2491 Mc Connell Trenton 0003090766 279 Hague Way San Diego NY 94940 1
220-43-7067 Fox Judith 000-137-9418 269 East Hague Street Richmond VA 55027 0
505-28-2848 Hardy Mitchell 001-2479822 73 Green Milton Drive Norfolk WA 69949 1
697-84-0401 Montes Leanne 000-018-0454 441 East Oak Parkway San Antonio MD 38169 1
727-35-9948 Long Jonathon 000-8761152 280 Nobel Avenue Anchorage LA NULL 1
875-54-8676 Stone Keisha 000-107-1947 763 White Fabien Way Fremont ND 08520 0
884-64-5876 Keller Steven 000-2787554 45 White Nobel Boulevard Milwaukee NY 29108 1
886-75-9197 Ellis Marie 001032-5109 35 East Second Boulevard Chicago IL 32390 1
975-80-3567 Salazar Johanna 001-028-0716 17 New Boulevard Jackson ND 71625 0
(10 filas afectadas)
|
Solo estoy usando SELECT * para simplificar las cosas para el artículo. Normalmente detallaría todas las columnas que desea comparar.
Esto solo funcionará para tablas con el mismo número de filas porque, si los autores tuvieran filas adicionales, seguiría diciendo que eran diferentes, ya que se devolverían las filas de los autores que no estaban en authorsCopy. Esto es porque EXCEPT devuelve los valores distintos de la consulta a la izquierda de la etiqueta EXCEPT operando que no se encuentran a partir de la consulta a la derecha
Este, esperemos que muestra lo que quiero decir.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
SELECCIONE ID de dirección,Dirección,Código postal
DE
(VALORES
(9, ‘929 Augustine lane, Staple Hill Ward South Gloucestershire UK’,’BS16 4LL’),
(10, ’45 Bradfield road, Parwich Derbyshire UK’,’DE6 1QN’)
) Tabla(ID de dirección,Dirección,código postal)
EXCEPTO
SELECCIONE Id de dirección,dirección,código postal de
(VALORES
(8, «‘The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK’,’NE29 7AD’),
(8, «‘The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK’,’NE29 7AD’),
(9, ‘929 Augustine lane, Staple Hill Ward South Gloucestershire UK’,’BS16 4LL’),
(10, ’45 Bradfield road, Parwich Derbyshire UK’,’DE6 1QN’)
) TableB(Address_ID,TheAddress,ThePostCode)
|
…yields …
|
1
2
3
4
|
Address_ID TheAddress ThePostCode
———– ———————————————- ———–
(0 fila(s) afectado)
|
…mientras …
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
SELECCIONAR ID de dirección,Dirección,Código postal DE
(VALORES
(8, «‘The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK»,» NE29 7AD»),
(8,»‘The Pippins», 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK», «NE29 7AD»),
(9, «929 Augustine lane, Staple Hill Ward South Gloucestershire UK», «BS16 4LL»),
(10, «45 Bradfield road, Parwich Derbyshire UK», «DE6 1QN»)
) TableB(id de dirección,dirección,código postal)
EXCEPTO
SELECCIONE Id de dirección,dirección,código postal
DE
(VALORES
(9, ‘929 Augustine lane, Staple Hill Ward South Gloucestershire UK’,’BS16 4LL’),
(10, ’45 Bradfield road, Parwich Derbyshire UK’,’DE6 1QN’)
) TableA(ID de dirección,Dirección,Código postal)
|
..results in …
|
1
2
3
4
5
|
Address_ID TheAddress ThePostCode
———– ————————————————————- ———–
8 ‘The Pippins’, 20 Gloucester Pl, Chirton Ward, Tyne & Wear UK NE29 7AD
(1 row(s) affected)
|
Esta característica de EXCEPT se puede utilizar con ventaja si desea comprobar en particular que TableAse encuentra dentro de TableB. Así que donde las tablas tienen un número diferente de filas, aún puedes compararlas.
es posible Que no desee comparar todas las columnas. Siempre debe especificar las columnas que desea comparar para determinar la ‘uniformidad’. Si sólo quería comparar la Dirección, por ejemplo, tendría que utilizar …
|
1
2
3
|
SELECCIONAR la dirección DE los autores
EXCEPTO
SELECCIONAR la dirección DE authorsCopy
|
El Exterior de la técnica de combinación
también Existe la técnica de la combinación externa. Esta es una técnica más general que le brinda facilidades adicionales. Si, por ejemplo, utiliza la unión externa completa, puede obtener las filas no coincidentes en cualquiera de las tablas. Esto le da una vista de «antes» y «después» de las alteraciones en los datos. Se utiliza de forma más general en sincronización para indicarle qué filas eliminar, insertar y actualizar.
We’ll just use the technique to get the altered rows in authorsCopy
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
SELECT authors.au_id, authors.au_lname, authors.au_fname, authors.phone, authors.address, authors.city, authors.state, authors.zip, authors.contrato
DE autores
LEFT OUTER JOIN authorsCopy
SOBRE los autores.au_ID = AuthorsCopy.au_ID
Y autores.au_lname =authorsCopy.au_lname
Y autores.au_fname =authorsCopy.au_fname
Y autores.teléfono = Copia de autor.phone
Y COALESCE (autores.address,») = COALESCE(authorsCopy.dirección,»)
Y COALESCE (autores.city,») =COALESCE (authorsCopy.city,»)
Y COALESCE (autores.state,») = COALESCE (authorsCopy.state,»)
Y COALESCE (autores.zip,») =COALESCE (authorsCopy.zip»).
Y autores.contrato =copia del autor.contrato
DONDE authorsCopy.au_ID ES NULL
|
Como puede ver, hay dificultades con null columnas con este enfoque, pero es tan rápido como los demás y le da más versatilidad para sus comparaciones.
Localizar las diferencias entre tablas
Es posible que necesite una forma rápida de ver qué columna y fila han cambiado. Una forma muy ingeniosa de hacer esto se publicó recientemente. Utilizó XML. ‘Compare Tablas E Informe De Las Diferencias Utilizando Xml Para Pivotar Los Datos’ (nota del editor: enlace obsoleto). Es inteligente, pero demasiado lento. Lo mismo se puede hacer puramente en SQL. Básicamente, se realiza una comparación de datos columna por columna basada en la clave principal, utilizando un par clave/valor. Si haces toda la mesa a la vez, es bastante lento: El mejor truco es hacerlo solo en aquellas filas donde sabes que hay una diferencia.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
|
INDICANDO @temp TABLA(au_id VARCHAR(11) CLAVE PRIMARIA). /*esto es las claves principales de las filas que han cambiado */
INSERTAR EN @Temp(au_ID) determine determine qué filas han cambiado
SELECCIONE au_ID
DE use use la técnica DE EXCEPCIÓN que es la más rápida en nuestras pruebas
(
SELECCIONE au_id, au_lname, au_fname, phone, , city, state, zip,
DE autores
EXCEPTO
SELECCIONE au_id, au_lname, au_fname, teléfono, dirección, ciudad, estado, código postal, contrato
DE authorsCopy
)f now ahora solo seleccionamos las columnas que han cambiado
SELECCIONE left hand.au_id,lefthand.name valor COMO original, derecho.valor COMO cambiado
DE (now ahora solo diseñamos las dos tablas como pares de valores clave, utilizando las versiones de cadena de los datos
SELECCIONAR autores.au_id, ‘au_lname’ COMO ‘nombre’,au_lname COMO ‘valor’
DE autores UNIÓN INTERNA @Temp alterada EN alterada.au_id=autores.au_id
UNIÓN
SELECCIONAR autores.au_id, ‘au_fname’ COMO ‘nombre’,au_fname COMO ‘valor’
DE autores UNIÓN INTERNA @Temp alterada EN alterada.au_id=autores.au_id
UNIÓN
SELECCIONAR autores.au_id, ‘phone’,phone
DE autores UNIÓN INTERNA @Temp alterada EN alterada.au_id=autores.au_id
UNIÓN
SELECCIONE autores.au_id, ‘dirección’,de dirección
DE autores INNER JOIN @Temp alterado EN la alteración.au_id=autores.au_id
UNIÓN
SELECCIONE autores.au_id, ‘Ciudad’ COMO ‘nombre’,de la Ciudad COMO ‘valor’
DE autores INNER JOIN @Temp alterado EN la alteración.au_id=autores.au_id
UNIÓN
SELECCIONE autores.au_id, ‘Estado’,estado
DE autores INNER JOIN @Temp alterado EN la alteración.au_id=autores.au_id
UNIÓN
SELECCIONE autores.au_id, ‘zip’,zip
DE autores JOIN @Temp INTERNO alterado EN altered.au_id=authors.au_id
UNION
SELECCIONAR autores.au_id, ‘contract’,CONVERT(CHAR(1),contract)
DE autores JOIN @Temp INTERNO alterado EN altered.au_id=authors.au_id) Izquierdo
JOIN INTERNO (
SELECCIONE authorsCopy.au_id, ‘au_lname’ COMO ‘nombre’,au_lname COMO ‘valor’
DE authorsCopy UNIÓN INTERNA @Temp alterada EN altered.au_id=authorsCopy.au_id
UNIÓN
SELECCIONE authorsCopy.au_id, ‘au_fname’,au_fname
DE los autoresCopy INNER JOIN @Temp alterado EN altered.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘phone’,phone
DE LOS autoresCopy INNER JOIN @Temp alterado EN altered.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘address’,address
DE authorsCopy UNIÓN INTERNA @Temp alterada EN altered.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘Ciudad’ COMO ‘nombre’,Ciudad COMO ‘valor’
DE los autores COPY UNIÓN INTERNA @Temp alterada EN alterada.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘Estado’,estado
DE LOS AUTORES Copy UNIÓN INTERNA @Temp alterada EN alterada.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘zip’,zip
DE authorsCopy UNIÓN INTERNA @Temp alterada EN altered.au_id=authorsCopy.au_id
UNION
SELECCIONE authorsCopy.au_id, ‘contract’, CONVERT(CHAR (1),contract)
DE authorsCopy UNIÓN INTERNA @ Temp alterada EN altered. au_id = authorsCopy. au_id) Mano derecha
EN mano izquierda. au_ID = mano derecha. au_ID
Y lefthand.name=righthand.name
DONDE el zurdo.valor<> a la derecha.valor
|
en nuestro ejemplo, esto daría:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
au_id nombre original cambiado
———– ——– —————————- ————————————
041-76-1076 dirección 29 de la Segunda Avenida 9 de la Segunda Avenida
187-42-2491 dirección 279 de la Haya Manera de 79 Haya Manera
220-43-7067 dirección 269 East Hague Street 69 East Hague Street
505-28-2848 dirección 73 Green Milton Drive 3 Green Milton Drive
697-84-0401 dirección 441 East Oak Parkway 41 East Oak Parkway
727-35-9948 dirección 280 Nobel Avenue 80 Nobel Avenue
875-54-8676 dirección 763 White Fabien Way 63 White Fabien Way
884-64-5876 dirección 45 White Nobel Boulevard 5 White Nobel Boulevard
886-75-9197 dirección 35 East Second Boulevard 5 East Second Boulevard
975-80-3567 dirección 17 New Boulevard 7 New Boulevard
|
Esta técnica rota las filas de las tablas que tienen diferencias en una tabla de valor de atributo de entidad (EAV) para que las diferencias dentro de una fila se puedan comparar y mostrar. Hace esta rotación por UNION ing el nombre y el valor de cadena de cada columna. Esta técnica funciona mejor donde no hay un gran número de diferencias.
Conclusiones
No existe un único método ideal para comparar los datos en tablas o resultados. Una de una serie de técnicas será la más relevante para cualquier tarea en particular. Todo depende precisamente de las respuestas que necesita y el tipo de tarea. ¿Necesita una comprobación rápida de que una tabla no ha cambiado, o necesita saber exactamente cuáles son los cambios? SQL es naturalmente rápido en hacer esta tarea y las comparaciones de tablas y resultados es una tarea familiar para muchos desarrolladores de bases de datos.
Si hay una regla general, diría que el trabajo exploratorio o ad hoc necesita una herramienta como SQL Data Compare, mientras que un proceso de rutina dentro de la base de datos requiere una técnica SQL cortada a mano.