Redgate Hub
Úvod
existuje několik důvodů, proč byste mohli potřebovat porovnat tabulky nebo výsledky.
- někdy stačí vědět, zda tabulky obsahují data, která jsou stejná nebo odlišná; žádné podrobnosti: jen ano nebo ne. To je typické u testovacích tvrzení, kde stačí vědět, zda vaše rutina nebo dávka produkuje výsledek se správnými daty v něm. pokud jsou pro parametry opatřeny konkrétními valemi. Je to buď špatné nebo správné
- občas potřebujete vědět, jaké řádky se změnily, aniž byste možná měli konkrétní informace o tom, které sloupce se změnily a jak.
- jsou chvíle, kdy máte velkou tabulku, pokud jde o sloupce i řádky, a potřebujete něco, co vám konkrétně ukáže sloupce, které změnily jejich hodnotu. Můžete to také chtít při sledování chyby v rutině, která by jinak mohla vyžadovat, abyste ztráceli čas skenováním „okem“.
budeme řešit tyto tři poměrně odlišné úkoly v SQL
pokud mají dvě tabulky jiný počet řádků, nemohou být samozřejmě stejné. Jsou však chvíle, kdy potřebujete vědět, zda Table_B obsahuje všechny řádky Table_A, bez rozdílů. Pokud si přejete více podrobností, možná budete chtít znát řádky v tabulce, které nejsou společné, nebo společné řádky, jak je uvedeno primárním klíčem, které se lišily. Proč se držet srovnání jen dvou tabulek? Existují způsoby, jak porovnat tolik, kolik potřebujete. (jako například při porovnávání metadat v několika snímcích databáze). Ano, existuje mnoho variací
máte nástroje a funkce, jak to udělat, jistě?
vždy existuje místo pro nástroje jako SQL Data Compare, TableDiff, tSQLt nebo Change Data Capture. Hodně záleží na okolnostech a typu úkolu. Problém provádění auditů změn dat v živém systému je samostatným tématem, stejně jako synchronizace tabulek a databází. Srovnání XML dokumentů je také mimo rozsah. Budeme jednat pouze s rutinní srovnání údajů v tabulkách,
já jsem největší pravděpodobností používat TSQL techniky, porovnat tabulky, když:
Rozvojových…
V průběhu vývoje databáze, mnoho tabulek si srovnání. Není to jen velké věci: Každý stůl-cenil funkce, například, potřebuje test kabelového svazku v build skriptu, který dělá, že to dělá to, co si myslíte, že to měli udělat podle všech myslitelných test okolností, a zahrnující všechny ošklivé okraje případech, kdy byl chycen testery v minulosti. Každý uložený postup potřebuje test, aby se ujistil, že proces, který provádí, dělá přesně to, co je zamýšleno, a nic jiného.
byly doby, kdy byla aktivita sestavení poměrně klidná, ale když máte noční test sestavení a integrace, je nejlepší ji zcela automatizovat a zbavit se fušky.
ETL
při automatizaci načítání dat do systému je často nutné testovat různé podmínky. Potřebujete aktualizovat stávající verze řádků a vkládat nové? Potřebujete past, abyste zabránili duplicitním záznamům nebo dokonce odstranili existující položky?
nastavení zkušebních dat.
všechny skripty v tomto článku používají tabulku z databáze ctihodných hospod. Použijeme tabulku autorů, ale zvýšíme počet řádků na 5000, abychom získali trochu realističtější velikost. Poskytl jsem zdroj pro tabulku s článkem.
I then created a copy of the table …
|
1
2
3
4
5
6
|
SELECT * INTO authorsCopy
FROM authors
GO
ALTER TABLE dbo.authorsCopy PŘIDAT OMEZENÍ PK_authorsCopy PRIMÁRNÍ KLÍČ CLUSTERED
(au_id) NA PRIMÁRNÍ
|
A pak změnil některé řádky.
|
1
2
3
4
5
|
AKTUALIZACE authorsCopy SET adresa=VĚCI(adresa,1,1,“)
, KDE au_ID V (
VYBRAT TOP 10 au_id
OD authorsCopy f
OBJEDNÁVKY telefonicky)
|
Takže teď dva stoly by měly být převážně stejné, s několika drobnými změnami v adresa pole,
Testování Chcete-li zjistit, zda jsou tabulky odlišné.
někdy jen chcete vědět, zda jsou tabulky stejné. Příkladem toho by byla kontrola, zda TVF funguje správně, porovnáním jeho výsledku s výsledkem existující tabulky se správnými výsledky. Obvyklým způsobem, jak toho dosáhnout, je skupina funkcí CHECKSUM()v SQL Serveru, protože jsou velmi rychlé.
pomocí kontrolních součtů
můžete pomocí funkce BINARY_CHECKSUM zkontrolovat, zda jsou tabulky stejné: dobře, zhruba stejné. Je to rychlé, ale není to dokonalé, jak ukážu za chvíli. Pokud máte například řadu testů, je to obecně dostačující.
|
1
2
3
4
5
6
7
8
9
|
, POKUD (
VYBERTE CHECKSUM_AGG(BINARY_CHECKSUM(*))
OD autorů)=(
VYBERTE CHECKSUM_AGG(BINARY_CHECKSUM(*))
OD authorsCopy)
VYBERTE ‚jsou pravděpodobně stejné,‘
VYBERTE ‚jsou různé‘
|
Pro tuto práci, váš stůl musí mít TEXT, NTEXT, IMAGE or CURSOR (nebo SQL_VARIANT u všech těchto typů) jako jeho základní typ. V dnešní době je to stále vzácnější, ale pokud máte nějaké komplikace, můžete donutit jakýkoli sloupec s jedním z nepodporovaných typů do podporovaného typu. V praxi obvykle používám rutinu, která kontroluje metadata a dělá to automaticky, ale není to hezké.
V pracovní verzi, tak by jste asi chtěli zadat seznam sloupců, a to zejména pokud jste museli udělat explicitní nátlak datové typy, nebo pokud vracíte jen určité sloupce,
Ani BINARY_CHECKSUM() ani jeho prostý sestra CHECKSUM() jsou zcela přesné říkat, že jestli se něco změnilo v řádku nebo tabulky. Ukážeme to tím, že se podíváme na běžná slova anglického jazyka obsažená v tabulce nazvané CommonWords.. Dalo by se očekávat, že všichni budou mít jiný kontrolní součet, ale to není tento případ.
|
1
2
3
4
5
6
7
8
9
|
VYBERTE řetězec, BINARY_CHECKSUM(string), JAKO „Součet“
OD commonWords
, KDE BINARY_CHECKSUM(řetězec) V
(
VYBERTE BINARY_CHECKSUM(string)
OD commonwords
GROUP BY BINARY_CHECKSUM(string)
HAVING COUNT(*) > 2)
OBJEDNÁVKY BINARY_CHECKSUM(string)
|
… což výsledek …
Ozbrojené s touto informací, můžeme rychle ukázat, že různé struny mohou mít stejný kontrolní součet,
|
1
2
3
|
VYBERTE BINARY_CHECKSUM(‚rákos nerd‘),
BINARY_CHECKSUM(‚žaloval hnízdo‘),
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‘)
|
….vzhledem k tomu,…
|
1
2
3
|
VYBERTE BINARY_CHECKSUM(‚To vypadá velmi podobně jako další‘),
BINARY_CHECKSUM(‚to vypadá velmi podobně jako další‘),
BINARY_CHECKSUM(‚To vypadá velmi podobně jako Další‘)
|
… vám dává různé kontrolní součty, jako je tato…
|
1
2
|
———– ———– ———–
-447523377 -447522865 -447654449
|
The sister function CHECKSUM() …
|
1
2
3
4
|
SELECT CHECKSUM(‚This looks very much jako další‘),
kontrolní SOUČET(‚to vypadá velmi podobně jako další‘),
kontrolní SOUČET(‚To vypadá velmi podobně jako Next‘)
|
… najde je, aby byly všechny stejné, protože je použití aktuální řazení a můj řazení pro databázi je case-insensitive. CHECKSUM() si klade za cíl najít řetězce stejné v kontrolním součtu, pokud jsou stejné v porovnání řetězců.
|
1
2
|
———– ———– ———–
-943581052 -943581052 -943581052
|
nejlepší, co můžete říct, je, že tam je velká pravděpodobnost, že se tabulky budou stejné, ale pokud potřebujete být naprosto jistí, pak použijte jiný algoritmus.
Pokud vám nevadí rozdíl v případě, že v textové řetězce, pak můžete použít CHECKSUM() místo BINARY_CHECKSUM()
skvělá hodnota této metody je, že, jakmile jste vypočte kontrolní součet, který potřebujete, můžete uložit jako hodnota ve sloupci tabulky místo toho, aby museli původní tabulky a proto může celý proces ještě rychlejší a zabere méně času. Pokud jste uložení kontrolního součtu hodnota vrácené CHECKSUM() ujistěte se, že jste zkontrolovat proti živé stůl s kontrolní součet, generované se stejnou řazení.
zde je jednoduchý příklad rutiny „co se změnilo“.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
–vytvoříme ‚součet‘ tabulka „on the fly“ pomocí SELECT INTO.
VYBRAT
au_ID,
BINARY_CHECKSUM(au_id, au_lname, au_fname, telefon , město , psč, ) JAKO
DO auchk
OD authorscopy
OBJEDNÁVKY au_ID
/* nyní dáme v omezení jen pro kontrolu, že jsme nevyhráli v loterii (velmi nepravděpodobné, ale ne zcela nemožné, že máme dvě řady se stejným součtem) */
ALTER TABLE AuChk PŘIDAT OMEZENÍ IsItUnique UNIKÁTNÍ ()
AKTUALIZACE authorscopy NASTAVIT au_fname=’Arthur‘
, KDE au_ID=’327-89-2366′
VYBERTE 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. Malá Skála 98949 1
|
A pak jsme jen uklidit.
|
1
2
3
|
/* a vložíme ji zpět na to, co to bylo, jako součást teardown */
AKTUALIZACE authorscopy NASTAVIT au_fname=’Arnold‘
, KDE au_ID=’327-89-2366′
|
samozřejmě, můžete použít spoušť, ale někdy možná budete chtít jen denní nebo týdenní zprávu změn bez narušení spouště do tabulky.
pomocí XML
jednou z obecných možností je porovnat XML verzi dvou tabulek, protože to dělá datový typ překlad do řetězců pro vás. Je pomalejší než kontrolní součet, ale spolehlivější.
|
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‘
VYBERTE ‚jsou různé‘
|
Zde můžete zadat typ srovnání zadáním řazení.
nebo to můžete provést porovnáním dat v tabulkách ..
|
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)))
VYBERTE ‚jsou skoro stejné‘
VYBERTE ‚jsou různé“ VYBRAT „jsou různé‘
|
… pomocí výpočtu kontrolního součtu XML verze tabulky. To vám umožní uložit kontrolní součet tabulky, se kterou porovnáváte.
zjištění, kde jsou rozdíly v tabulce
nejjednodušším úkolem je, kde tabulky mají stejný počet řádků a identickou strukturu tabulky. Někdy chcete vědět, které řádky jsou různé a které chybí. Máte, samozřejmě, určit, co máte na mysli „stejné“, zejména v případě, že dvě tabulky mají různé sloupce. Metoda, kterou se rozhodnete provést srovnání, je obecně určena těmito údaji.
UNIE … SKUPINY PODLE technika
klasický přístup k porovnávání tabulek, je použít UNION ALLSELECT závěrce, která obsahuje sloupce, které chcete porovnat, a potom GROUP BY ty sloupy. Je zřejmé, že aby to fungovalo, musí být v GROUP BY sloupec s jedinečnými hodnotami a primární klíč je pro to ideální. Ani jedna tabulka jsou povoleny duplikáty. Pokud mají různý počet řádků, zobrazí se jako rozdíly.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
SELECT DISTINCT au_ID
OD
(
VYBERTE au_ID
(
VYBERTE au_id, au_lname, au_fname, telefon, adresa, město, stát, zip, smlouvy
OD autora
UNION VŠECHNY
VYBERTE au_id, au_lname, au_fname, telefon, adresa, město, stát, zip, smlouvy
OD authorsCopy) BothOfEm
GROUP BY au_id, au_lname, au_fname, telefon, adresa, město, stát, zip, smlouvy
HAVING COUNT(*)<2) f
|
Pokud jednu z tabulek má duplicitní, pak to bude dát falešný výsledek, jako tady, kde máte dvě tabulky, které jsou velmi odlišné a výsledek vám řekne, že jsou stejné! Z tohoto důvodu je vhodné zahrnout sloupce, které tvoří primární klíč, a řádky zahrnout pouze jednou!
|
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
(
, VYBERTE Address_ID,TheAddress,ThePostCode
(
HODNOTY
, (9, ‚929 Augustine varování, Základní Ward Hill South Gloucestershire UK‘,’BS16 4LL‘),
(10, ’45 Bradfield road, Parwich Derbyshire UK‘,’DE6 1QN‘)
) TableA(Address_ID,TheAddress,ThePostCode)
UNIE
VYBERTE Address_ID,TheAddress,ThePostCode
(
HODNOTY
(8, „Pippins“, 20 Gloucester Pl, Chirton Oddělení, 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 řadě(s) postižené)
|
tato technika může být použita pro srovnání více než dvě tabulky. Jen je třeba, aby UNION ALL tabulky, které potřebujete, aby porovnat a změnit na HAVING klauzule filtrovat pouze řádky, které nejsou ve všech tabulkách.
použití kromě
nyní můžete použít mnohem čistší a mírně rychlejší EXCEPT.
|
1
2
3
|
SELECT * from autoři
s VÝJIMKOU
SELECT * from authorsCopy
|
To ukazuje všechny řádky v autorů, které nejsou nalezeny v authorsCopy. Pokud jsou stejné, vrátí žádné řádky
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
au_id au_lname au_fname telefon, adresa, město, stát, zip smlouvy
———– ———– ——— ———— ————————– ———– —– —– ——–
041-76-1076 Sosa Sonja 000-198-8753 29 Second Avenue Omaha CT 23243 0
187-42-2491 Mc Connell Trenton 0003090766 279 Haagu, Jak San Diego NY 94940 1
220-43-7067 Fox Judith 000-137-9418 269 Východ Haagu Street Richmond, VA 55027 0
505-28-2848 Hardy Mitchell 001-2479822 73 Milton Green Disk Norfolk WA 69949 1
697-84-0401 Montes Leanne 000-018-0454 441 East Oak Parkway San Antonio MD 38169 1
727-35-9948 Dlouho Jonathon 000-8761152 280 Nobelovu Avenue Anchorage LA NULL 1
875-54-8676 Kámen Keisha 000-107-1947 763 Bílé Fabien Způsobem Fremont ND 08520 0
884-64-5876 Keller, Steven 000-2787554 45 Bílá Nobelovu 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 Nových Boulevard Jackson ND 71625 0
(10 řádek(y), vliv)
|
já jsem jen pomocí VYBERTE * chcete-li udržet věci jednoduché pro tento článek. Normálně byste rozepsali všechny sloupce, které chcete porovnat.
Toto bude fungovat pouze pro tabulky se stejným počtem řádků, protože, kdyby autoři měli více řádků, to bych ještě říci, že jsou odlišné od řady Autorů, které nebyly v authorsCopy by být vrácen. Je to proto, že EXCEPT vrátí všechny odlišné hodnoty z dotazu nalevo od EXCEPT operandu, které nejsou také našel z dotazu na pravé straně
Tento, doufejme, že ukazuje, co mám na mysli,
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
VYBERTE Address_ID,TheAddress,ThePostCode
(HODNOTY
, (9, ‚929 Augustine varování, Základní Ward Hill South Gloucestershire UK‘,’BS16 4LL‘),
(10, ’45 Bradfield road, Parwich Derbyshire UK‘,’DE6 1QN‘)
) TableA(Address_ID,TheAddress,ThePostCode)
s VÝJIMKOU
VYBERTE Address_ID,TheAddress,ThePostCode z
(HODNOTY
(8, „Pippins“, 20 Gloucester Pl, Chirton Oddělení, Tyne & Nosit UK‘,’NE29 7AD‘),
(8, „Pippins“, 20 Gloucester Pl, Chirton Sboru, 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 řádek(y), vliv)
|
…že …
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
, VYBERTE Address_ID,TheAddress,ThePostCode Z
(HODNOTY
(8, „Pippins“, 20 Gloucester Pl, Chirton Oddělení, Tyne & Nosit UK‘,’NE29 7AD‘),
(8, „Pippins“, 20 Gloucester Pl, Chirton Sboru, Tyne & Nosit UK‘,’NE29 7AD‘),
, (9, ‚929 Augustine varování, Základní Ward Hill South Gloucestershire UK‘,’BS16 4LL‘),
(10, ’45 Bradfield road, Parwich Derbyshire UK‘,’DE6 1QN‘)
) TableB(Address_ID,TheAddress,ThePostCode)
s VÝJIMKOU
VYBERTE Address_ID,TheAddress,ThePostCode
(HODNOTY
, (9, ‚929 Augustine varování, Základní Ward Hill South Gloucestershire UK‘,’BS16 4LL‘),
(10, ’45 Bradfield road, Parwich Derbyshire UK‘,’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)
|
tato funkce EXCEPT může být použita jako výhoda, pokud si přejete zkontrolovat, zda TableA je obsažena v TableB. Takže tam, kde tabulky mají jiný počet řádků, můžete je stále porovnávat.
možná nebudete chtít porovnávat všechny sloupce. Vždy byste měli určit sloupce, které chcete porovnat, abyste určili „stejnost“. Pokud jste jen chtěl porovnat Adresu, například, budeš používat …
|
1
2
3
|
VYBERTE adresu Z autorů
s VÝJIMKOU
VYBERTE adresu Z authorsCopy
|
Vnější spojení, technika
k Dispozici je také technika vnější spojení. Jedná se o obecnější techniku, která vám poskytne další zařízení. Pokud například použijete úplné vnější spojení, můžete získat bezkonkurenční řádky v obou tabulkách. To vám dává „před“ a “ po “ zobrazení změn v datech. Používá se obecněji při synchronizaci, aby vám řekl, jaké řádky odstranit, vložit a aktualizovat.
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.smlouva
OD autora
left OUTER JOIN authorsCopy
NA autory.au_ID = AuthorsCopy.au_ID
A autorů.au_lname =authorsCopy.au_lname
A autorů.au_fname =authorsCopy.au_fname
A autorů.telefon =authorsCopy.telefon
a COALESCE (autoři.adresa,“)=COALESCE (authorsCopy.adresa,“)
a COALESCE (autoři.město,“) =KOALESCE (authorsCopy.město,“)
a KOALESCE (autoři.stát,“) =KOALESCE (authorsCopy.stát,“)
a KOALESCE (autoři.zip,“) =COALESCE (authorsCopy.zip,“)
a autoři.smlouva =authorsCopy.smlouva
, KDE authorsCopy.au_ID JE NULL
|
Jak můžete vidět, tam jsou problémy s null sloupce s tímto přístupem, ale to je stejně rychle jako ostatní, a to vám dává spíše větší všestrannost pro vaše srovnání.
nalezení rozdílů mezi tabulkami
možná budete potřebovat rychlý způsob, jak zjistit, jaký sloupec a řádek se změnily. Velmi důmyslný způsob, jak toho dosáhnout, byl nedávno zveřejněn. Používá XML. „Porovnat tabulky a nahlásit rozdíly pomocí Xml k otočení dat „(poznámka editora: odkaz zastaralý). Je to chytré, ale příliš pomalé. Totéž lze provést čistě v SQL. V zásadě provádíte porovnávání dat podle sloupce na základě primárního klíče pomocí páru klíč / hodnota. Pokud uděláte celou tabulku najednou, je to poměrně pomalé: nejlepší trik je udělat to pouze na těch řádcích, kde víte, že je rozdíl.
|
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
|
s UVEDENÍM @temp TABULKY(au_id VARCHAR(11) PRIMÁRNÍ KLÍČ) /*to platí primárního klíče řádků, které byly změněny */
VLOŽIT DO @Temp(au_ID) –určit, které řádky se změnily
VYBERTE au_ID
… použít KROMĚ techniku pak tedy je nejrychlejší v našich testech
(
VYBERTE au_id, au_lname, au_fname, telefon , město, stát, zip,
OD autora
s VÝJIMKOU
VYBERTE au_id, au_lname, au_fname, telefon, adresa, město, stát, zip, smlouvy
OD authorsCopy
) … teď už jen VYBRAT ty sloupce, které byly změněny
ZVOLTE vlevo.au_id,levý.jméno,levý.hodnotu JAKO původní,Pravé.hodnoty, JAK se změnil
OD (–teď už jen vyložit dvě tabulky jako dvojice klíč-hodnota, pomocí řetězec verzí dat
VYBERTE autorů.au_id, ‚au_lname‘ JAKO ‚name‘,au_lname JAKO ‚hodnota‘
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, ‚au_fname‘ JAKO ‚name‘,au_fname JAKO ‚hodnota‘
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, „telefon“, telefonu
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, „adresa“, adresa
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, „City“ JAKO „jméno“, Města JAKO ‚hodnota‘
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, „Státní“, stát
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, ‚zip‘,zip
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id
UNIE
VYBERTE autorů.au_id, „smlouva“, CONVERT(CHAR(1),smlouvy)
OD autorů INNER JOIN @Temp změněn NA změnit.au_id=autoři.au_id) Vlevo
INNER JOIN (
VYBERTE authorsCopy.au_id, ‚au_lname‘ JAKO ‚name‘,au_lname JAKO ‚hodnota‘
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, ‚au_fname‘,au_fname
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, „telefon“, telefonu
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, „adresa“, adresa
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, „City“ JAKO „jméno“, Města JAKO ‚hodnota‘
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, „Státní“, stát
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, ‚zip‘,zip
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id
UNIE
VYBERTE authorsCopy.au_id, „smlouva“, CONVERT(CHAR(1),smlouvy)
OD authorsCopy INNER JOIN @Temp změněn NA změnit.au_id=authorsCopy.au_id) pravé
NA levém.au_ID=pravé ruce.au_ID
A vlevo.name=pravé ruce.jméno
, KDE levém.hodnota<>pravé.hodnota
|
v našem příkladu by to dalo:
|
1
2
3
4
5
6
7
8
9
10
11
12
|
au_id originální název změnil
———– ——– —————————- ————————————
041-76-1076 adresa 29 Second Avenue 9 Druhé Avenue
187-42-2491 adresu 279 Haagu Způsob, 79 Haagu Způsob, jak
220-43-7067 adresu 269 Východ Haagu Street 69 Východ Haagu Ulici
505-28-2848 adresa 73 Milton Green Drive 3 Zelené Milton Drive
697-84-0401 adresu 441 East Oak Parkway 41 East Oak Parkway
727-35-9948 adresu 280 Nobelovu Avenue 80 Nobelovu Avenue
875-54-8676 adresu 763 Bílé Fabien Způsob, 63 Bílá Fabien Způsob, jak
884-64-5876 adresa 45 Bílá Nobelovu Boulevard 5 Bílá Nobelovu Boulevard
886-75-9197 adresa 35 East Second Boulevard 5 East Second Boulevard
975-80-3567 adresa 17 Nových Boulevard 7 Nových Boulevard
|
Tato technika se otáčí řádky tabulky, které mají rozdíly v účetní Jednotka-atribut-hodnota (EPH) stůl tak, že rozdíly v řadě mohou být porovnány a zobrazeny. To dělá tuto rotaci UNIONing název a řetězec-hodnota každého sloupce. Tato technika funguje nejlépe tam, kde není velký počet rozdílů.
závěry
neexistuje jediný ideální způsob porovnání dat v tabulkách nebo výsledcích. Jedna z mnoha technik bude pro každý konkrétní úkol nejdůležitější. Je to všechno na přesně odpovědi, které potřebujete a typ úkolu. Potřebujete rychlou kontrolu, zda se tabulka nezměnila, nebo potřebujete přesně vědět, jaké jsou změny? SQL je přirozeně rychlý při provádění tohoto úkolu a srovnání tabulek a výsledků je známým úkolem mnoha vývojářů databází.
Pokud existuje obecné pravidlo, řekl bych, že průzkumná nebo ad-hoc práce potřebuje nástroj, jako je porovnání dat SQL, zatímco rutinní proces v databázi vyžaduje ručně řezanou techniku SQL.