Hub Redgate
introdução
Existem várias razões pelas quais você pode precisar comparar tabelas ou resultados.
- às vezes, basta saber se as tabelas contêm dados que são os mesmos ou diferentes; nenhum detalhe: apenas SIM ou não. Isto é típico com asserções de teste, onde você só precisa saber se a sua rotina ou lote produz um resultado com os dados certos nele. quando fornecido com valores específicos para os parâmetros. É errado ou certo
- ocasionalmente, você precisa saber que linhas mudaram sem, talvez, ser particular sobre quais colunas mudaram e como.
- Existem momentos em que você tem uma tabela grande em termos de colunas e linhas, e você precisa de algo que lhe mostra especificamente a(s) coluna (s) que mudou o seu valor. Você também pode querer isso ao rastrear um bug em uma rotina que pode exigir que você perca tempo digitalizando ‘por olho’.
estaremos lidando com estas três tarefas bastante diferentes em SQL
Se duas tabelas têm um número diferente de linhas, elas não podem, naturalmente, ser as mesmas. No entanto, há momentos em que você precisa saber se Table_B contém todas as linhas de Table_A, sem diferenças. Se você desejar mais detalhes, você pode até querer saber as linhas em qualquer tabela que não são comuns, ou as linhas comuns, como indicado pela chave primária, que eram diferentes. Porquê comparar apenas duas mesas? Há formas de comparar as que precisares. (como, por exemplo, quando você está comparando os metadados em vários instantâneos de banco de dados). Sim, existem muitas variações
você tem ferramentas e recursos para fazer isso, certamente?
há sempre um lugar para ferramentas como a comparação de Dados SQL, TableDiff, tSQLt ou a captura de dados de alteração. Muito depende das circunstâncias e do tipo de tarefa. O problema de fazer auditorias sobre mudanças de dados em um sistema ao vivo é um tópico separado, assim como a sincronização de tabelas e bases de dados. A comparação de documentos XML também está fora de âmbito. Nós vamos lidar puramente com a comparação de rotina dos dados nas tabelas
Eu sou mais provável de usar técnicas TSQL para comparar tabelas quando:
desenvolvimento…
no curso do desenvolvimento de uma base de dados, um monte de tabelas são comparados. Não é apenas a coisa grande: cada função de valor de mesa, por exemplo, Precisa de um arnês de teste no script de construção que se certifique de que ele faz o que você acha que deve fazer em todas as circunstâncias de teste concebíveis, e incorporando todos os casos de borda desagradável onde ele foi pego pelos testadores no passado. Cada procedimento armazenado precisa de um teste para se certificar de que o processo que ele executa faz exatamente o que é pretendido e nada mais.houve um tempo em que a atividade de construção foi bastante vagarosa, mas quando você tem um teste de construção e integração noturna, é melhor automatizá-lo inteiramente e se livrar da tarefa.
ETL
quando você está automatizando a carga de dados em um sistema, você muitas vezes precisa testar várias condições. Você precisa atualizar as versões existentes das linhas, bem como inserir as novas? Precisa de uma armadilha para evitar entradas duplicadas ou mesmo apagar entradas existentes?
configurar os dados do ensaio.
todos os programas deste artigo usam uma tabela da Venerável base de dados de PUBS. Vamos usar a tabela de autores, mas vai aumentar o número de linhas um pouco para 5000, a fim de obter um tamanho que é um pouco mais realista. Eu forneci a fonte para a mesa com o artigo.
I then created a copy of the table …
|
1
2
3
4
5
6
|
SELECT * INTO authorsCopy
FROM authors
GO
ALTER TABLE dbo.authorsCopy ADICIONAR RESTRIÇÃO PK_authorsCopy CHAVE PRIMÁRIA de CLUSTER
(au_id) NO PRINCIPAL
IR
|
E, em seguida, alteradas algumas das linhas.
|
1
2
3
4
5
|
ATUALIZAÇÃO authorsCopy DEFINIR endereço=COISAS(endereço,1,1,”)
WHERE au_ID EM (
SELECT TOP 10 au_id
a PARTIR de authorsCopy f
PEDIDO POR telefone)
|
Então, agora as duas tabelas devem ser, predominantemente, mesmo com algumas pequenas alterações no campo de endereço de
Teste para ver se as mesas são diferentes.
às vezes você só quer saber se as tabelas são as mesmas. Um exemplo disso seria verificar se um TVF está funcionando corretamente, comparando seu resultado com o de uma tabela existente com os resultados corretos. A maneira usual de fazer isso é com o CHECKSUM()grupo de funções no servidor SQL, porque eles são muito rápidos.
usando códigos de validação
pode usar a função BINARY_CHECKSUM para verificar se as tabelas são as mesmas: bem, mais ou menos as mesmas. É rápido, mas não é perfeito, como vou demonstrar em um momento. Se você tem uma série de testes, por exemplo, é geralmente suficiente.
|
1
2
3
4
5
6
7
8
9
|
SE (
SELECIONE CHECKSUM_AGG(BINARY_CHECKSUM(*))
a PARTIR de autores)=(
SELECIONE CHECKSUM_AGG(BINARY_CHECKSUM(*))
a PARTIR de authorsCopy)
SELECIONE “elas são, provavelmente, o mesmo’
ELSE
SELECIONE “eles são diferentes’
|
Para isso, a tabela não deve ter TEXT, NTEXT, IMAGE or CURSOR (ou SQL_VARIANT com qualquer um desses tipos) como tipo base. Hoje em dia, isso é cada vez mais raro, mas se você tiver algum tipo de complicação, você pode coagir qualquer coluna com um dos tipos não suportados em um tipo suportado. Na prática, eu geralmente uso uma rotina que verifica os metadados e faz isso automaticamente, mas não é bonito.
Em uma versão de trabalho, você provavelmente quer especificar a lista de colunas, especialmente se você está tendo para fazer uma coerção explícita de tipos de dados, ou se você estiver verificando apenas algumas colunas,
Nem BINARY_CHECKSUM() nem a sua simples irmã CHECKSUM() são totalmente precisos em dizer a você se alguma coisa mudou em uma linha ou tabela. Vamos mostrar isso olhando para as palavras comuns da língua inglesa, contidas em uma tabela chamada CommonWords.. Seria de esperar que todos tivessem um checksum diferente, mas não é esse o caso.
|
1
2
3
4
5
6
7
8
9
|
SELECIONE a seqüência de caracteres, BINARY_CHECKSUM(string) COMO “Soma de verificação”
a PARTIR de commonWords
ONDE BINARY_CHECKSUM(seqüência de caracteres) EM
(
SELECIONE BINARY_CHECKSUM(string)
a PARTIR de commonwords
GRUPO BINARY_CHECKSUM(string)
HAVING COUNT(*) > 2)
ORDER BY BINARY_CHECKSUM(string)
|
… dando o resultado …
Armado com esta informação, podemos rapidamente demonstrar que diferentes seqüências de caracteres pode ter a mesma soma de verificação
|
1
2
3
|
SELECIONE BINARY_CHECKSUM(‘reed nerd’),
BINARY_CHECKSUM(‘processou o ninho”),
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’)
|
….considerando que os…
|
1
2
3
|
SELECIONE BINARY_CHECKSUM(‘Este se parece muito com o avançar’),
BINARY_CHECKSUM(‘este se parece muito com o avançar’),
BINARY_CHECKSUM(‘Este se parece muito com o Avançar’)
|
… dá-lhe as somas de verificação diferentes como este…
|
1
2
|
———– ———– ———–
-447523377 -447522865 -447654449
|
The sister function CHECKSUM() …
|
1
2
3
4
|
SELECT CHECKSUM(‘This looks very much como o próximo’),
CHECKSUM(‘isto parece-se muito com o próximo’),
CHECKSUM(‘isto parece-se muito com o próximo’)
|
… encontra-os todos iguais, porque está a usar a colação actual e a minha colação para a base de dados é insensível a maiúsculas. CHECKSUM() tem como objetivo encontrar strings iguais em checksum se eles são iguais em uma comparação de string.
|
1
2
|
———– ———– ———–
-943581052 -943581052 -943581052
|
Então, o melhor que você pode dizer é que há uma forte probabilidade de que as tabelas será o mesmo, mas se você precisa ter a certeza absoluta, em seguida, use outro algoritmo.
Se você não mente diferença no caso em seqüências de caracteres de texto e, em seguida, você pode usar CHECKSUM() em vez de BINARY_CHECKSUM()
O grande valor desta técnica é que, depois de calculada a soma de verificação que você precisa, você pode armazená-lo como um valor na coluna de uma tabela em vez de precisar a tabela original e, portanto, você pode fazer todo o processo ainda mais rápido, e levam menos tempo. Se estiver a guardar o valor do código de validação devolvido por CHECKSUM() certifique-se que verifica a tabela ao vivo com um código de validação gerado com a mesma colação.
aqui está um exemplo simples da rotina “o que mudou”.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
–vamos criar um ‘checksum’ tabela ‘na mosca’ usando o SELECT INTO.
SELECIONE
au_ID
BINARY_CHECKSUM(au_id, au_lname, au_fname, telefone , bairro, cidade , cep ) COMO
EM auchk
a PARTIR de authorscopy
ORDER BY au_ID
/* agora nós vamos colocar em uma restrição apenas para verificar o que ainda não ganhou na loteria (muito improvável, mas não totalmente impossível que temos duas linhas com a mesma soma de verificação) */
ALTER TABLE AuChk ADICIONAR RESTRIÇÃO IsItUnique EXCLUSIVO ()
ATUALIZAÇÃO authorscopy CONJUNTO au_fname=’Arthur’
WHERE au_ID=’327-89-2366′
SELECIONE 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 OF 98949 1
|
e então nós apenas arrumamos.
|
1
2
3
|
/* e é só colocá-lo de volta ao que era, como parte da desmontagem */
ATUALIZAÇÃO authorscopy CONJUNTO au_fname=’Arnold’
WHERE au_ID=’327-89-2366′
|
De curso, você pode usar um disparador, mas às vezes você quer apenas uma diária ou semanal, do relatório de alterações, sem a intrusão de um gatilho em uma tabela.
usando XML
uma possibilidade geral é comparar a versão XML das duas tabelas, uma vez que isto faz a tradução do tipo de dados em cadeias de caracteres para si. É mais lento do que a abordagem Checksum, mas mais confiável.
|
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
SELECIONE “eles são diferentes’
|
Aqui, você pode especificar o tipo de comparação, especificando o agrupamento.
ou você pode fazer isso, comparando os dados nas tabelas ..
|
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)))
SELECIONE “eles são praticamente o mesmo’
ELSE
SELECIONE “eles são diferentes’ SELECIONAR ‘eles são diferentes’
|
(…) pelo cálculo de uma soma de verificação da versão XML da tabela. Isto permite-lhe armazenar o código de validação da tabela com a qual está a comparar.
descobrir onde as diferenças estão em uma tabela
a tarefa mais simples é onde as tabelas têm um número idêntico de linhas, e uma estrutura de tabela idêntica. Às vezes você quer saber quais as linhas são diferentes, e quais estão faltando. É claro que tem de especificar o que quer dizer com “o mesmo”, especialmente se as duas tabelas tiverem colunas diferentes. O método que você escolhe para fazer a comparação é geralmente determinado por estes detalhes.
A UNIÃO de TODOS os … GRUPO PELA técnica
A abordagem clássica para a comparação de tabelas é usar uma UNION ALL para SELECT declarações que incluam as colunas que você deseja comparar e, em seguida, GROUP BY as colunas. Obviamente, para isso funcionar, deve haver uma coluna com valores únicos no GROUP BY, e a chave primária é ideal para isso. Nenhuma tabela é permitida duplicados. Se tiverem números diferentes de linhas, estas aparecerão como diferenças.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
SELECT DISTINCT au_ID
A PARTIR de
(
SELECT au_ID
a PARTIR do
(
SELECT au_id, au_lname, au_fname, telefone, endereço, cidade, estado, cep, contrato
a PARTIR de autores
a UNIÃO de TODOS os
SELECT au_id, au_lname, au_fname, telefone, endereço, cidade, estado, cep, contrato
a PARTIR de authorsCopy) BothOfEm
GRUPO au_id, au_lname, au_fname, telefone, endereço, cidade, estado, cep, contrato
HAVING COUNT(*)<2) f
|
Se a uma das mesas tem uma duplicata, em seguida, ele vai te dar um resultado falso, como aqui, onde você tem duas tabelas que são muito diferentes e o resultado diz que eles são iguais! Por esta razão, é uma boa ideia incluir a(s) coluna (s) que constituem a chave primária, e incluir apenas as linhas uma 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
a PARTIR do
(
SELECIONAR Address_ID,TheAddress,ThePostCode
DE
(
VALORES
(9, ‘929 Agostinho lane, Grampos Hill Ala Sul Gloucestershire reino UNIDO’,’BS16 4LL’),
(10, ’45 Bradfield estrada, Parwich Derbyshire, reino UNIDO’,’DE6 1QN’)
) TableA(Address_ID,TheAddress,ThePostCode)
UNION ALL
SELECIONE Address_ID,TheAddress,ThePostCode
DE
(
VALORES
(8, “‘O Pippins”, De 20 de Gloucester Pl, Chirton Ala, 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 linha(s) afetado)
|
A técnica pode ser usada para a comparação de mais de duas tabelas. Você só precisa de UNION ALL as tabelas que você precisa para comparar e alterar a cláusula HAVING para filtrar apenas as linhas que não estão em todas as tabelas.
usando excepto
pode agora usar o muito mais limpo e ligeiramente mais rápido EXCEPT.
|
1
2
3
|
SELECT * from authors
EXCEPT
SELECT * from authorsCopy
|
Isso mostra todas as linhas em autores que não são encontrados em authorsCopy. Se eles são o mesmo, iria retornar nenhuma linha
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
au_id au_lname au_fname telefone endereço cidade estado código postal do contrato
———– ———– ——— ———— ————————– ———– —– —– ——–
041-76-1076 Sosa Sonja 000-198-8753 29 Segunda Avenida Omaha CT 23243 0
187-42-2491 Mc Connell Trenton 0003090766 279 Haia Forma de San Diego NY 94940 1
220-43-7067 Fox Judith 000-137-9418 269 Leste Haia Rua Richmond VA 55027 0
505-28-2848 Hardy Mitchell 001-2479822 73 Verde Milton Unidade de Norfolk WA 69949 1
697-84-0401 Montes Leanne 000-018-0454 441 Leste de Carvalho Parkway, San Antonio MD 38169 1
727-35-9948 Longo Jonathon 000-8761152 280 Nobel Avenue, Anchorage LA NULO 1
875-54-8676 Pedra Keisha 000-107-1947 763 Branco Fabien Forma Fremont ND 08520 0
884-64-5876 Keller Steven 000-2787554 45 Branco Nobel Boulevard Milwaukee NY 29108 1
886-75-9197 Ellis Marie 001032-5109 35 East Segunda Avenida de Chicago, IL, 32390 1
975-80-3567 Salazar Johanna 001-028-0716 17 Novo Boulevard Jackson ND 71625 0
(10 linha(s) afetado)
|
eu estou usando apenas SELECIONE * para manter as coisas simples para o artigo. Normalmente Descreveria todas as colunas que quiser comparar.
isto só irá funcionar para tabelas com o mesmo número de linhas porque, se os autores tivessem linhas extra, ainda assim diria que elas eram diferentes, uma vez que as linhas nos autores que não estavam em authorsCopy seriam devolvidas. Isso é porque EXCEPT retorna qualquer valor distinto da consulta para a esquerda do EXCEPT operando que também não são encontrados a partir da consulta à direita
Este, espero que mostra o que eu quero dizer
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
SELECIONE Address_ID,TheAddress,ThePostCode
DE
(VALORES
(9, ‘929 Agostinho lane, Grampos Hill Ala Sul Gloucestershire reino UNIDO’,’BS16 4LL’),
(10, ’45 Bradfield estrada, Parwich Derbyshire, reino UNIDO’,’DE6 1QN’)
) TableA(Address_ID,TheAddress,ThePostCode)
EXCEPT
SELECIONE Address_ID,TheAddress,ThePostCode a partir de
(VALORES
(8, “‘O Pippins”, De 20 de Gloucester Pl, Chirton Ala, Tyne & Desgaste do reino UNIDO’,’NE29 7AD’),
(8, “‘O Pippins”, De 20 de Gloucester Pl, Chirton Ala, 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 linha(s) afetado)
|
…enquanto …
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
SELECIONAR Address_ID,TheAddress,ThePostCode a PARTIR de
(VALORES
(8, “‘O Pippins”, De 20 de Gloucester Pl, Chirton Ala, Tyne & Desgaste do reino UNIDO’,’NE29 7AD’),
(8, “‘O Pippins”, De 20 de Gloucester Pl, Chirton Ala, Tyne & Desgaste do reino UNIDO’,’NE29 7AD’),
(9, ‘929 Agostinho lane, Grampos Hill Ala Sul Gloucestershire reino UNIDO’,’BS16 4LL’),
(10, ’45 Bradfield estrada, Parwich Derbyshire, reino UNIDO’,’DE6 1QN’)
) TableB(Address_ID,TheAddress,ThePostCode)
EXCEPT
SELECIONE Address_ID,TheAddress,ThePostCode
DE
(VALORES
(9, ‘929 Agostinho lane, Grampos Hill Ala Sul Gloucestershire reino UNIDO’,’BS16 4LL’),
(10, ’45 Bradfield estrada, Parwich Derbyshire, reino UNIDO’,’DE6 1QN’)
) TableA(Address_ID,TheAddress,ThePostCode)
|
..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)
|
Este recurso de EXCEPT pode ser usada para vantagem de se particularmente quiser verificar que TableA está contido dentro de TableB. Então, onde as tabelas têm um número diferente de linhas você ainda pode compará-las.
pode não querer comparar todas as colunas. Você deve sempre especificar as colunas que deseja comparar para determinar o ‘sameness’. Se você só quis comparar o Endereço por exemplo, você usaria …
|
1
2
3
|
SELECIONE o endereço DE autores
EXCEPT
SELECIONE o endereço DE authorsCopy
|
O Exterior técnica de Associação
Há também a técnica de associação externa. Esta é uma técnica mais geral que lhe dá facilidades adicionais. Se, por exemplo, você usar a junção exterior completa, então você pode obter as linhas incomparáveis em qualquer tabela. Isto lhe dá uma visão’ antes ‘e’ depois ‘ das alterações nos dados. É usado de forma mais geral na sincronização para lhe dizer quais as linhas a apagar, inserir e atualizar.
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
a PARTIR de autores
LEFT OUTER JOIN authorsCopy
EM autores.au_ID = AuthorsCopy.au_ID
E autores.au_lname =authorsCopy.au_lname
E autores.au_fname =authorsCopy.au_fname
E autores.phone =authorsCopy.phone
e COALESCE(autores.endereço,”) = COALESCE (authscopy.endereço,”)
e COALESCE (autores.cidade,”) = COALESCE (authorsCopy.cidade,”)
e COALESCE(autores.) = COALESCE (authscopy.estado,”)
e carvão (autores.zip,”) = COALESCE (authorsCopy.zip,”)
e autores.contract =authorsCopy.contrato
ONDE authorsCopy.au_ID É NULO
|
Como você pode ver, existem dificuldades nulo colunas com esta abordagem, mas é tão rápido como os outros e dá a você mais versatilidade para suas comparações.
localizando as diferenças entre as tabelas
pode precisar de uma forma rápida de ver que coluna e linha mudou. Uma maneira muito engenhosa de fazer isso foi publicada recentemente. Usou XML. “Compare tabelas e relate as diferenças usando Xml para rodar os dados” (Nota do editor: link depreciado). É inteligente, mas muito lento. A mesma coisa pode ser feita puramente em SQL. Basicamente, você executa uma coluna por coluna de comparação de dados com base na chave primária, usando um par chave/valor. Se você fizer a mesa inteira de uma vez é bastante lento: o melhor truque é fazer isso apenas naquelas linhas onde você sabe que há uma diferença.
|
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
|
INFORMANDO @temp TABELA(au_id VARCHAR(11) PRIMARY KEY) /*este detém as chaves primárias de linhas que foram alteradas */
INSERIR EM @Temp(au_ID) –determinar quais linhas foram alteradas
SELECT au_ID
a PARTIR de –use o EXCEPTO técnica qhich é o mais rápido em nossos testes
(
SELECT au_id, au_lname, au_fname, telefone , cidade, estado, cep,
a PARTIR de autores
EXCEPT
SELECT au_id, au_lname, au_fname, telefone, endereço, cidade, estado, cep, contrato
a PARTIR de authorsCopy
)f–agora vamos SELECIONAR apenas as colunas que foram alterados
SELECIONE a esquerda.au_id,da mão esquerda.nome,da mão esquerda.valor que o original,Direita.valor alterado
a PARTIR de (–agora é só colocar as duas tabelas como pares de valores de chave, usando a seqüência de versões de dados
SELECIONE autores.au_id ‘au_lname’ COMO ‘nome’,au_lname COMO ‘value’
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id ‘au_fname’ COMO ‘nome’,au_fname COMO ‘value’
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id, “telefone”, telefone
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id, ‘endereço’,o endereço de
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id, ‘Cidade’ COMO ‘nome’,a Cidade COMO ‘value’
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id, ‘Estado’,de estado
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id ‘zip’,zip
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id
UNION
SELECIONE autores.au_id, “contrato”, CONVERT(CHAR(1),contrato)
a PARTIR de autores INNER JOIN @Temp alterado alterado.au_id=autores.au_id) da mão Esquerda
INNER JOIN (
SELECIONE authorsCopy.au_id ‘au_lname’ COMO ‘nome’,au_lname COMO ‘value’
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id ‘au_fname’,au_fname
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id, “telefone”, telefone
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id, ‘endereço’,o endereço de
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id, ‘Cidade’ COMO ‘nome’,a Cidade COMO ‘value’
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id, ‘Estado’,de estado
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id ‘zip’,zip
a PARTIR de authorsCopy INNER JOIN @Temp alterado alterado.au_id=authorsCopy.au_id
UNION
SELECIONE authorsCopy.au_id, ‘contract’, CONVERT(CHAR (1), contract)
from authscopy INNER JOIN @Temp altered ON altered. au_id=authscopy.au_id) rightHand
ON lefthand. au_ID=righthand. au_ID
e lefthand.name=righthand.name onde esquerda.valor<>righthand.valor
|
no nosso exemplo, isso daria:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
au_id nome original alterado
———– ——– —————————- ————————————
041-76-1076 endereço de 29 Segunda Avenida 9 Second Avenue
187-42-2491 endereço 279 Haia de Forma 79 Haia Forma
220-43-7067 endereço 269 Leste Haia Rua 69 Leste da Haia de Rua
505-28-2848 endereço 73 Verde Milton Unidade 3 Verde Milton Unidade
697-84-0401 endereço 441 Leste de Carvalho Parkway 41 Leste de Carvalho Parkway
727-35-9948 endereço de 280 Nobel da Avenida 80 Nobel Avenida
875-54-8676 endereço 763 Branco Fabien Maneira 63 Branco Fabien Forma
884-64-5876 endereço 45 Branco Nobel Avenida 5 Branco Nobel Boulevard
886-75-9197 endereço de 35 East Segunda Avenida 5 East Segundo Boulevard
975-80-3567 endereço de 17 Novos Avenida 7 Novo Boulevard
|
Esta técnica gira as linhas das tabelas que têm diferenças em uma Entidade-atributo-valor (EAV) tabela para que as diferenças dentro de uma linha podem ser comparados e apresentados. Ele faz esta rotação por UNIONing the name and string-value of each column. Esta técnica funciona melhor quando não há um grande número de diferenças.
conclusões
não existe um único método ideal para comparar os dados em tabelas ou resultados. Uma de várias técnicas será a mais relevante para qualquer tarefa em particular. Tudo depende precisamente das respostas que você precisa e do tipo de tarefa. Você precisa de uma verificação rápida de que uma tabela não mudou, ou você precisa saber exatamente quais são as mudanças? SQL é naturalmente rápido em fazer esta tarefa e comparações de tabelas e resultados é uma tarefa familiar para muitos desenvolvedores de banco de dados.se existe uma regra geral, eu diria que o trabalho exploratório ou ad-hoc precisa de uma ferramenta como a comparação de Dados SQL, enquanto que um processo de rotina dentro da base de dados requer uma técnica de SQL de corte manual.