Daugiau

Kaip transformuoti reikšmes naudojant žodyną ar paieškos lentelę?

Kaip transformuoti reikšmes naudojant žodyną ar paieškos lentelę?


Skaitau eilutes (~ 20 laukų vienoje eilutėje) iš duomenų bazės naudodamas „SearchCursor“ ir dedu jas į masyvą. Tada perjungiu masyvą ir naudoju „InsertCursor“, kad įterpčiau juos į funkcijų klasę kitoje duomenų bazėje.

Problema, turiu pakeisti lauko reikšmes šaltinio duomenyse. Pavyzdžiui, stulpelyje gali būti eilutės „T“, „true“, „Taip“ ir „1“, ir prieš jas įrašant į paskirties stulpelį, jos turi būti konvertuotos į „TRUE“ eilutės vertę.

  • Šaltinio stulpelyje gali būti kelios vertės, kurias reikia susieti su viena paskirties verte. Tai yra aukščiau pateiktas pavyzdys.
  • Stulpelyje gali būti kelios peržiūros. Pavyzdžiui, vieno stulpelio šaltinio reikšmė gali būti „A“, kuris transformuojamas į „Z1“, o tame pačiame stulpelyje „B“ transformuojamas į „Z2“, o toje pačioje stulpelyje „C“ transformuojamas į "Z1" (kelios šaltinio vertės susietos su ta pačia paskirties verte).
  • Yra daug stulpelių, kuriems reikės sukurti peržiūras. Norėčiau, kad kiekvienam stulpeliui būtų skirta skirtinga žodyno / paieškos lentelė, nes greičiausiai bus subtilių skirtumų tarp stulpelių, o bandymai pakartotinai naudoti žodynus taps apmaudu.

Kaip turėčiau kreiptis į šią problemą?


1 atnaujinimas

Mėginys naudojant @ mr.adam pasiūlymus: eilutėje išmetama klaidajei paieškos eilutė [raktas] .lower () (raktas [1]):su žinia„TypeError“: „int“ objektas nėra indeksuojamas

lookup = {3: ("TRUE", ["t", "true", "1", "taip"]), 4: ("FALSE", ["f", "false", "0", " ne "])} eilutės = [] eilutės.append ((" abc "," 123 "," xyz "," True "," F ")) eilutės.append ((" lmo "," 456 "," xyz "," 1 "," ne ")) rows.append ((" tuv "," 456 "," xyz "," taip "," 0 ")) eilutėms eilutėse: raktui, reikšmei lookup.iteritems (): jei eilutė [raktas]. žemesnė () ieškant (raktas [1]): eilutė [raktas] = paieška (raktas [0]) eilutėms eilutėse: spausdinti eilutę

2 atnaujinimas

po tam tikro papildomo kasimo, nutraukiant aukščiau nurodytą liniją,eilutė [raktas]. žemesnė ()vertina ikitiesa"kaip tikėtasi duomenų rinkinio pirmos eilutės 4 stulpelyje. Klaida išmetama vertinantįšios eilutės sąlyga,peržiūra (raktas [1]).


Aš padaryčiau žodyną, kuris atrodytų maždaug taip:

paieškos = {"TRUE": ["t", "true", "1", "taip"], "FALSE": ["f", "false", "0", "ne"]}

Tada logika gali atrodyti taip:

eilutėms eilutėse: i diapazone (0, len (eilutė)): raktui reikšmė lookup.iteritems (): jei str (eilutė [i]). vertė (eilutė [i] = raktas)

Šis kodas atnaujins visą lentelę vienu metu, eilutę po eilutės. Tai būtų problema, jei turite lauką1, kuriame reikšmė „T“ turėtų būti išversta į „TIESA“, ir lauką2, kur „T“ turėtų būti išversta į „Į viršų“. Jei taip yra, galite pakeisti žodyną taip:

lookups = {fieldindexnumber: ("TRUE", ["t", "true", "1", "taip"]), fieldindexnumber: ("FALSE", ["f", "false", "0", " ne "]), fieldindexnumber: (" Nežinomas ", [" u "]), # įsitikinkite, kad antrasis objektų rinkinys yra sąrašas []}

Tada tiesiog pakeiskite kilpų struktūrą į:

eilutėms eilutėse: raktui reikšmė lookup.iteritems (): jei eilutė [raktas] .lower () vertėje [1]: eilutė [raktas] = reikšmė [0]

Atkreipkite dėmesį, kad visas galimas reikšmes padariau mažosiomis, o tada esamą vertę perrašiau į mažąsias. Pastebėjau, kad tai labai naudinga daug kartų, tačiau gali būti, kad ne tai, ko ieškote.

Galbūt norėsite jį įgyvendinti kitaip, bet aš tikrai rekomenduočiau naudoti kai kurią šio žodyno versiją, nes galite ją tiesiog išsaugoti scenarijaus viršuje ir ji bus aiškiai išdėstyta, jei norite pakeisti / pridėti raktų ir verčių poras.


Mano pasiūlymas: pirmiausia sukurkite žodynų žodyną. Pagrindinio diktanto raktai bus įvairių jūsų laukų rodyklės vieta„SearchCursor“(kaip atsakyme @ mr.adam). Vertės bus sub-žodynai, kurių raktai yra norimos išvesties reikšmės ir kurių reikšmės yra galimų įėjimų, kurie bus paversti atitinkamu raktu, sąrašai.

vertimai = {# 1 laukas: 0: {"TRUE": ["t", "true", "1", "yes"], "FALSE": ["f", "false", "0", " ne "]}, # 2 laukas: 1: {" Z1 ": [" A "," C "]," Z2 ": [" B "]} # ir tt}

Tada apibrėžkite bendrą vertimo funkciją, kuri priima įvesties vertę ir žodyną ta pačia forma kaip ir aukščiau pateikti žodynai, grąžindami pakeistą vertę, jei randama atitiktis, arba nepakitusią įvesties vertę:

def translate (in_value, translation_dict): out_value = in_value for k, v in translation_dict.iteritems (): jei out_value v: out_value = k pertrauka return out_value

Galiausiai pritaikykite šią funkciją kiekvienai kiekvienos eilutės vertei, naudodami lauko rodyklę, norėdami patraukti atitinkamą vertimo žodyną:

eilutėms eilutėse: i i xrange (len (eilutė)): eilutė [i] = versti (eilutė [i], vertimai [i])

Tada eilutės bus atnaujintos ir bus galima naudoti su jūsų„InsertCursor“.


Dar viena rekomendacija: užuot nukopijavę eiles į atmintį, pakeiskite jas ir naudokite„InsertCursor“, Viską daryčiau skrisdamas, taip:

su arcpy.da.InsertCursor (out_table, [field_list]) kaip ic: su arcpy.da.SearchCursor (in_table, [field_list]) kaip sc: eilutei sc: i i xrange (len (eilutė)): eilutė [ i] = versti (eilutė [i], vertimai [i]) ic.insertRow (eilutė)

Pastabos

Žodyno & ltTKey, TValue ir gt bendrojoje klasėje pateikiamas raktų rinkinio ir reikšmių rinkinio susiejimas. Kiekvieną žodyno priedą sudaro vertė ir su ja susijęs raktas. Vertę gauti naudojant jos raktą yra labai greita, artima O (1), nes žodyno & ltTKey, TValue ir gt klasė įgyvendinama kaip maišos lentelė.

Paieškos greitis priklauso nuo TKey nurodyto tipo maišos algoritmo kokybės.

Kol objektas naudojamas kaip raktas žodyne & ltTKey, TValue & gt, jis neturi pasikeisti jokiu būdu, kuris turi įtakos jo maišos vertei. Kiekvienas žodyno & ltTKey, TValue ir gt raktas turi būti unikalus, atsižvelgiant į žodyno lygybės palyginimą. Raktas negali būti nulinis, tačiau vertė gali būti, jei jo tipas TValue yra nuorodos tipas.

Žodynui & ltTKey, TValue & gt reikalinga lygybė, kad būtų galima nustatyti, ar raktai yra vienodi. Galite nurodyti „IEqualityComparer & ltT & gt“ bendrosios sąsajos įgyvendinimą naudodami konstruktorių, kuris priima palyginimo parametrą, jei nenurodote įgyvendinimo, naudojamas numatytasis bendrojo lygiateisiškumo lygintuvas „EqualityComparer & ltT & gt.Default“. Jei „TKey“ tipas įdiegia bendrąją „System.IEquatable & ltT & gt“ sąsają, numatytasis lygybės palyginimo įrankis naudoja tą įgyvendinimą.

Pvz., Galite naudoti „StringComparer“ klasės neskiriamas didžiųjų ir mažųjų raidžių palyginimus, kad sukurtumėte žodynus su didžiosiomis ir mažosiomis eilutėmis.

Žodyno & ltTKey, TValue & gt talpa yra elementų, kuriuos gali turėti žodynas & ltTKey, TValue & gt, skaičius. Kai elementai pridedami prie žodyno & ltTKey, TValue & gt, talpa automatiškai padidinama, jei reikia, perskirstant vidinį masyvą.

Tik .NET Framework: Jei naudojate labai didelius žodyno & ltTKey, TValue ir gt objektus, galite padidinti maksimalų pajėgumą iki 2 milijardų elementų 64 bitų sistemoje nustatydami įgalintą konfigūravimo elemento & ltgcAllowVeryLargeObjects & gt atributą tiesą vykdymo laiko aplinkoje.

Apibendrinant kiekvienas žodyno elementas traktuojamas kaip „KeyValuePair“ & ltKKey, TValue & gt struktūra, nurodanti vertę ir jos raktą. Prekių grąžinimo tvarka nėra apibrėžta.

Foreach C # kalbos sakinys (kiekvienam C ++, For Every Visual Basic) grąžina kolekcijos elementų tipo objektą. Kadangi žodynas & ltTKey, TValue & gt yra raktų ir verčių rinkinys, elemento tipas nėra rakto tipas arba vertės tipas. Vietoj to, elemento tipas yra „KeyValuePair“ & ltTKey, „TValue“ ir gt raktų tipo ir vertės tipo. Pavyzdžiui:

Foreach pareiškimas yra apvedimas aplink surašytoją, leidžiantis tik skaityti iš kolekcijos, o ne rašyti jai.

Kadangi raktus galima paveldėti ir pakeisti jų elgesį, jų absoliutaus unikalumo negalima garantuoti lyginant metodą „Lygus“.


1 Atsakymas 1

Turite šiek tiek kasti, kad pamatytumėte, kaip žodynas įgyvendinamas C # - jis nėra toks akivaizdus, ​​kaip „HashMap“ (maišos lentelė) ar „TreeMap“ (rūšiuojamas medis) (arba „ConcurrentSkipListMap“ - praleisti sąrašą).

Jei įsigilinsite į skyrių „Pastabos“:

„Dictionary“ bendrojoje klasėje pateikiamas raktų rinkinio ir reikšmių rinkinio susiejimas. Kiekvieną žodyno priedą sudaro vertė ir su ja susijęs raktas. Vertę gauti naudojant jos raktą yra labai greita, artima O (1), nes „Dictionary“ klasė įgyvendinama kaip maišos lentelė.

Ir mes turime tai. Tai maišos stalas. Atkreipkite dėmesį, kad ten susiečiau „Wikipedia“ straipsnį - tai gana geras skaitinys. Galbūt norėsite perskaityti skyrių apie susidūrimo sprendimą. Galima gauti patologinį duomenų rinkinį, kuriame peržiūra perduodama O (N) (pvz., Viskas, ką įterpiate, dėl kažkokių priežasčių maišos lentelėje patenka į tą pačią maišos vertę ar indeksą ir jums lieka tiesinis zondavimas).

Nors žodynas yra bendros paskirties sprendimas, neturėtumėte apeiti konkrečių tipų (pvz., Žodyno) - turėtumėte apeiti sąsajas. Šiuo atveju ta sąsaja yra ID Dictionary (docs). Šiuo tikslu jūs puikiai sugeba parašyti savo žodyno diegimą, kuris optimaliai padaro jūsų turimiems duomenims viską.

Kalbant apie įvairių paieškų efektyvumą?

  • Vaikščiojimas pagal nerūšiuotą sąrašą: O (N)
  • Dvejetainė rūšiuoto masyvo paieška: O (log N)
  • Rūšiuotas medis: O (log N)
  • Maišos lentelė: O (1)

Daugumai žmonių maišos lentelė yra tai, ko jie nori.

Galite pastebėti, kad vietoj to „SortedDictionary“ norite:

Bendroji „SortedDictionary“ & ltTKey, TValue & gt klasė yra dvejetainis paieškos medis su O (log n) paieška, kur n yra žodyno elementų skaičius. Šiuo požiūriu jis yra panašus į bendrąją klasę „SortedList“ & ltTKey, TValue & gt. Abi klasės turi panašius objektų modelius ir abi turi O (log n) paiešką.

Nors vėlgi, jei duomenų struktūra nėra tokia, kuri idealiai veiktų su jūsų duomenimis, jums suteikiami įrankiai (sąsajos), kad galėtumėte parašyti geriausiai jūsų duomenims tinkančią struktūrą.

Pats žodynas yra abstraktus duomenų tipas. Jūs man duodate žodyną, ir aš žinau, ką aš galiu su juo padaryti, ir visas ten esančias priemones, kurias galėčiau naudoti pagal savo prigimtį žodyną. Jei duotumėte man „ArrayList“, atsidurčiau rašydamas savo kodą, norėdamas ieškoti, įterpti ar ištrinti elementus iš sąrašo. Tai eikvoja mano laiką ir taip pat reiškia, kad klaidai yra didesnė tikimybė, nes aš vėl ir vėl kopijuoju kodą iš vietos į vietą.


Pratęsimo metodai

Bando pašalinti vertę nurodytu raktu iš žodyno.

Bando pridėti nurodytą raktą ir vertę į žodyną.

Sukuria nekintamą masyvą iš nurodytos kolekcijos.

Sukuria nekintamą žodyną iš esamo elementų rinkinio, pritaikydamas transformacijos funkciją šaltinio raktams.

Sukuria nekintamą žodyną, pagrįstą tam tikra sekos transformacija.

Surašo ir transformuoja seką ir sukuria nekintamą jos turinio žodyną.

Suskaičiuoja ir transformuoja seką ir sukuria nekintamą jos turinio žodyną naudodamas nurodytą klavišų palygiklį.

Suskaičiuoja ir transformuoja seką ir sukuria nekintamą jos turinio žodyną, naudodamas nurodytą raktą ir reikšmių palyginimus.

Surašo seką ir sukuria nekintamą jos turinio maišos rinkinį.

Surašo seką, sukuria nekintamą maišos rinkinį ir naudoja nustatytam tipui nurodytą lygybės palyginimą.

Surašo seką ir sukuria nekintamą jos turinio sąrašą.

Surašo ir transformuoja seką ir sukuria nekintamą rūšiuojamą jos turinio žodyną.

Suskaičiuoja ir transformuoja seką ir, naudodamas nurodytą raktų palygiklį, sukuria nekintamą rūšiuojamą jos turinio žodyną.

Surašo ir transformuoja seką ir sukuria nekintamą rūšiuojamą jos turinio žodyną, naudodamas nurodytą raktą ir reikšmių palyginimus.

Surašo seką ir sukuria nekintamą surūšiuotą jos turinio rinkinį.

Surašo seką, sukuria nekintamą surūšiuotą jos turinį ir naudoja nurodytą palyginimą.

Pateikia „DataTable“, kurioje yra „DataRow“ objektų kopijos, atsižvelgiant į įvesties „IEnumerable“ & ltT & gt objektą, kur bendras parametras T yra „DataRow“.

Nukopijuoja „DataRow“ objektus į nurodytą „DataTable“, atsižvelgiant į įvesties objektą „IEnumerable & ltT & gt“, kur bendras parametras T yra „DataRow“.

Nukopijuoja „DataRow“ objektus į nurodytą „DataTable“, atsižvelgiant į įvesties objektą „IEnumerable & ltT & gt“, kur bendras parametras T yra „DataRow“.

Taiko akumuliatoriaus funkciją sekai.

Taiko akumuliatoriaus funkciją sekai. Nurodyta pradinė vertė naudojama kaip pradinė kaupiklio vertė.

Taiko akumuliatoriaus funkciją sekai. Nurodyta pradinė vertė naudojama kaip pradinė akumuliatoriaus vertė, o nurodyta funkcija naudojama rezultato vertei pasirinkti.

Nustato, ar visi sekos elementai atitinka sąlygą.

Nustato, ar sekoje yra elementų.

Nustato, ar kuris nors sekos elementas atitinka sąlygą.

Pridedama reikšmė sekos pabaigoje.

Grąžina įvestį, įvestą kaip IEnumerable & ltT & gt.

Apskaičiuoja dešimtainių reikšmių sekos, gautos iškviečiant transformavimo funkciją kiekvienam įvesties sekos elementui, vidurkį.

Apskaičiuoja dvigubų reikšmių, gautų iškviečiant transformavimo funkciją kiekvienam įvesties sekos elementui, sekos vidurkį.

Apskaičiuoja Int32 reikšmių sekos vidurkį, gautą iškviečiant transformacijos funkciją kiekvienam įvesties sekos elementui.

Apskaičiuoja Int64 reikšmių, gautų iškviečiant transformavimo funkciją kiekvienam įvesties sekos elementui, sekos vidurkį.

Apskaičiuoja negaliojančių dešimtainių reikšmių sekos vidurkį, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja niekinių dvigubų reikšmių sekos vidurkį, gautą iškviečiant transformacijos funkciją kiekvienam įvesties sekos elementui.

Apskaičiuoja niekinių Int32 reikšmių sekos vidurkį, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja niekinių Int64 reikšmių sekos vidurkį, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja negaliojančių pavienių reikšmių sekos vidurkį, gaunamą iškviečiant kiekvieno įvesties sekos elemento transformacijos funkciją.

Apskaičiuoja pavienių reikšmių, gautų iškviečiant kiekvieno įvesties sekos elemento transformacijos funkciją, sekos vidurkį.

Perduoda „IEnumerable“ elementus į nurodytą tipą.

Sujungia dvi sekas.

Naudodamas numatytąjį lygybės lygiklį, nustato, ar sekoje yra nurodytas elementas.

Naudodamas nurodytą „IEqualityComparer“ & lt & gt nustato, ar sekoje yra nurodytas elementas.

Grąžina elementų skaičių sekoje.

Pateikia skaičių, nurodantį, kiek elementų nurodytoje sekoje atitinka sąlygą.

Grąžina nurodytos sekos elementus arba numatytąją tipo parametro vertę pavieniui rinkiniui, jei seka tuščia.

Grąžina nurodytos sekos elementus arba nurodytą reikšmę pavieniui rinkiniui, jei seka tuščia.

Grąžina atskirus sekos elementus, naudodamas numatytąjį lygybės palyginimo įrankį, kad būtų galima palyginti reikšmes.

Grąžina atskirus sekos elementus naudodamas nurodytą „IEqualityComparer & ltT & gt“, kad palygintumėte reikšmes.

Grąžina elementą pagal nurodytą indeksą sekoje.

Grąžina elementą nurodytoje indekso sekoje arba numatytąją vertę, jei indeksas yra už diapazono ribų.

Naudojant numatytąjį lygybės lygiklį, palyginamos vertės, nustatomas dviejų sekų skirtumas.

Naudojant nurodytą „IEqualityComparer & ltT & gt“ vertėms palyginti, gaunamas nustatytas dviejų sekų skirtumas.

Grąžina pirmąjį sekos elementą.

Grąžina pirmąjį sekos elementą, kuris atitinka nurodytą sąlygą.

Grąžina pirmąjį sekos elementą arba numatytąją vertę, jei sekoje nėra elementų.

Grąžina pirmąjį sekos elementą, kuris atitinka sąlygą, arba numatytąją vertę, jei tokio elemento nerandama.

Grupuoja sekos elementus pagal nurodytą klavišų parinkiklio funkciją.

Grupuoja sekos elementus pagal nurodytą klavišų parinkimo funkciją ir lygina raktus naudodamas nurodytą palygiklį.

Grupuoja sekos elementus pagal nurodytą klavišų parinkiklio funkciją ir projektuoja kiekvienos grupės elementus naudodami nurodytą funkciją.

Grupuoja sekos elementus pagal klavišų parinkiklio funkciją. Klavišai lyginami naudojant lygintuvą, o kiekvienos grupės elementai projektuojami naudojant nurodytą funkciją.

Grupuoja sekos elementus pagal nurodytą klavišų parinkimo funkciją ir sukuria rezultato vertę iš kiekvienos grupės ir jos rakto.

Grupuoja sekos elementus pagal nurodytą klavišų parinkiklio funkciją ir sukuria rezultato vertę iš kiekvienos grupės ir jos rakto. Raktai lyginami naudojant nurodytą palygiklį.

Grupuoja sekos elementus pagal nurodytą klavišų parinkiklio funkciją ir sukuria rezultato vertę iš kiekvienos grupės ir jos rakto. Kiekvienos grupės elementai projektuojami naudojant nurodytą funkciją.

Grupuoja sekos elementus pagal nurodytą klavišų parinkiklio funkciją ir sukuria rezultato vertę iš kiekvienos grupės ir jos rakto. Pagrindinės vertės palyginamos naudojant nurodytą palygiklį, o kiekvienos grupės elementai projektuojami naudojant nurodytą funkciją.

Koreliuoja dviejų sekų elementus pagal raktų lygybę ir grupuoja rezultatus. Raktams palyginti naudojamas numatytasis lygybės lygintuvas.

Koreliuoja dviejų sekų elementus pagal pagrindinę lygybę ir grupuoja rezultatus. Nurodytas „IEqualityComparer & ltT & gt“ naudojamas raktams palyginti.

Naudojant numatytąjį lygybės palyginimo įrankį, nustatomos dviejų sekų aibės susikirtimo reikšmės.

Naudojant nurodytą „IEqualityComparer & ltT & gt“ vertėms lyginti, sukuriamas dviejų sekų susikirtimas.

Koreliuoja dviejų sekų elementus pagal suderinamus raktus. Raktams palyginti naudojamas numatytasis lygybės lygintuvas.

Koreliuoja dviejų sekų elementus pagal suderinamus raktus. Nurodytas „IEqualityComparer & ltT & gt“ naudojamas raktams palyginti.

Grąžina paskutinį sekos elementą.

Grąžina paskutinį sekos elementą, kuris atitinka nurodytą sąlygą.

Grąžina paskutinį sekos elementą arba numatytąją vertę, jei sekoje nėra elementų.

Grąžina paskutinį sekos elementą, kuris atitinka sąlygą, arba numatytąją vertę, jei tokio elemento nerandama.

Pateikia Int64, nurodantį bendrą elementų skaičių sekoje.

Pateikia Int64, nurodantį, kiek elementų sekoje tenkina sąlygą.

Grąžina didžiausią vertę bendroje sekoje.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir pateikia didžiausią dešimtainę vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina didžiausią dvigubą reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina didžiausią Int32 vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina didžiausią Int64 reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina maksimalią nulinę dešimtainę vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina maksimalią nulinę dvigubą reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina maksimalią niekinę Int32 reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina maksimalią niekinę Int64 reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina maksimalią niekinę „Single“ reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina didžiausią Single vertę.

Iškviečia transformacijos funkciją kiekviename bendrosios sekos elemente ir grąžina didžiausią gautą vertę.

Grąžina mažiausią vertę bendroje sekoje.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią dešimtainę vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią dvigubą vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią Int32 vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią Int64 vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią niekinę dešimtainę vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią niekinę dvigubą vertę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią niekinę Int32 reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią niekinę Int64 reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią niekinę niekinę reikšmę.

Iškviečia transformacijos funkciją kiekviename sekos elemente ir grąžina mažiausią Single vertę.

Iškviečia transformacijos funkciją kiekviename bendrosios sekos elemente ir grąžina mažiausią gautą vertę.

Filtruoja IEnumerable elementus pagal nurodytą tipą.

Rikiuoja sekos elementus didėjimo tvarka pagal raktą.

Rūšiuoti sekos elementus didėjimo tvarka, naudojant nurodytą palygiklį.

Rūšiuoja sekos elementus mažėjančia tvarka pagal raktą.

Rūšiuoti sekos elementus mažėjančia tvarka, naudojant nurodytą palygiklį.

Pridedama reikšmė sekos pradžioje.

Keičia elementų eilės eilės tvarką.

Projektuoja kiekvieną sekos elementą į naują formą.

Projektuoja kiekvieną sekos elementą į naują formą, įtraukdami elemento rodyklę.

Projektuoja kiekvieną sekos elementą į IEnumerable & ltT & gt ir išlygina gautas sekas į vieną seką.

Kiekvieną sekos elementą projektuoja į „IEnumerable & ltT & gt“ ir išlygina gautas sekas į vieną seką. Kiekvieno šaltinio elemento rodyklė naudojama to elemento projektuojamoje formoje.

Kiekvieną sekos elementą projektuoja į „IEnumerable & ltT & gt“, išlygina gautas sekas į vieną seką ir kiekviename joje esančiame elemente iškviečia rezultatų parinkimo funkciją.

Kiekvieną sekos elementą projektuoja į „IEnumerable & ltT & gt“, išlygina gautas sekas į vieną seką ir kiekviename joje esančiame elemente iškviečia rezultatų parinkimo funkciją. Kiekvieno šaltinio elemento indeksas naudojamas tarpinėje projektuojamoje to elemento formoje.

Nustato, ar dvi sekos yra lygios, palygindami elementus, naudodami numatytąjį jų tipo lygybės palygiklį.

Nustato, ar dvi sekos yra lygios, palygindami jų elementus naudodami nurodytą „IEqualityComparer & ltT & gt“.

Grąžina vienintelį sekos elementą ir išmeta išimtį, jei sekoje nėra tiksliai vieno elemento.

Grąžina vienintelį sekos elementą, kuris atitinka nurodytą sąlygą, ir išmeta išimtį, jei yra daugiau nei vienas toks elementas.

Grąžina vienintelį sekos elementą arba numatytąją vertę, jei seka tuščia, šis metodas išmeta išimtį, jei sekoje yra daugiau nei vienas elementas.

Grąžina vienintelį sekos elementą, kuris atitinka nurodytą sąlygą, arba numatytąją vertę, jei tokio elemento nėra, šis metodas pateikia išimtį, jei sąlygą atitinka daugiau nei vienas elementas.

Apeina nurodytą skaičių elementų sekoje ir tada grąžina likusius elementus.

Pateikia naują suskaičiuotą kolekciją, kurioje yra elementai iš šaltinio, o paskutiniai šaltinio kolekcijos elementai praleisti.

Apeina elementus iš eilės tol, kol nurodyta sąlyga yra teisinga, ir tada grąžina likusius elementus.

Apeina elementus iš eilės tol, kol nurodyta sąlyga yra teisinga, ir tada grąžina likusius elementus. Elemento indeksas naudojamas predikato funkcijos logikoje.

Apskaičiuoja dešimtainių reikšmių sekos sumą, gaunamą iškviečiant kiekvieno įvesties sekos elemento transformacijos funkciją.

Apskaičiuoja dvigubų verčių sekos sumą, gautą iškviečiant kiekvieno įvesties sekos elemento transformacijos funkciją.

Apskaičiuoja Int32 reikšmių sekos sumą, gaunamą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja Int64 reikšmių sekos sumą, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja niekinių dešimtainių reikšmių sekos sumą, gaunamą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja niekinių dvigubų reikšmių sekos sumą, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja niekinių Int32 reikšmių sekos sumą, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja negaliojančių Int64 reikšmių sekos sumą, gautą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja negaliojančių pavienių reikšmių sekos sumą, gaunamą iškviečiant transformacijos funkciją kiekviename įvesties sekos elemente.

Apskaičiuoja pavienių reikšmių, gautų iškreipiant transformavimo funkciją kiekviename įvesties sekos elemente, sekos sumą.

Grąžina nurodytą skaičių gretimų elementų nuo sekos pradžios.

Pateikia naują suskaičiuotą kolekciją, kurioje yra paskutiniai skaičiavimo elementai iš šaltinio.

Grąžina elementus iš sekos tol, kol nurodyta sąlyga yra teisinga.

Grąžina elementus iš sekos tol, kol nurodyta sąlyga yra teisinga. Elemento indeksas naudojamas predikato funkcijos logikoje.

Pagal nurodytą klavišų parinkiklio funkciją sukuria žodyną & ltTKey, TValue & gt iš IEnumerable & ltT & gt.

Pagal nurodytą klavišų parinkiklio funkciją ir raktų palyginimą sukuria žodyną & ltTKey, TValue & gt iš IEnumerable & ltT & gt.

Pagal IEnumerable & ltT & gt sukuria žodyną & ltTKey, TValue & gt pagal nurodytas raktų parinkimo ir elementų parinkimo funkcijas.

Pagal IEnumerable & ltT & gt sukuria žodyną & ltTKey, TValue & gt pagal nurodytą klavišų parinkiklio funkciją, palyginimo priemonę ir elementų parinkiklio funkciją.

Sukurdamas „HashSet“ & ltT & gt iš „IEnumerable & ltT & gt“, naudodamas raktą palyginančią priemonę.

Pagal nurodytą klavišų parinkiklio funkciją sukuria paiešką & ltTKey, TElement & gt iš IEnumerable & ltT & gt.

Pagal nurodytą klavišų parinkiklio funkciją ir raktų palyginimą sukuria paiešką & ltTKey, TElement & gt iš IEnumerable & ltT & gt.

Pagal IEnumerable & ltT & gt pagal nurodytas raktų parinkiklio ir elementų parinkiklio funkcijas sukuria paiešką & ltTKey, TElement & gt.

Pagal IEnumerable & ltT & gt sukuria paiešką & ltTKey, TElement & gt pagal nurodytą klavišų parinkiklio funkciją, palyginimo ir elementų parinkimo funkciją.

Naudodamas numatytąjį lygybės lygiklį, sukuria dviejų sekų rinkinį.

Naudojant nurodytą „IEqualityComparer“ & lt & gt sukuria dviejų sekų rinkinį.

Filtruoja reikšmių seką pagal predikatą.

Filtruoja reikšmių seką pagal predikatą. Kiekvieno elemento indeksas naudojamas predikato funkcijos logikoje.

Sukuria sekų rinkinį su elementais iš dviejų nurodytų sekų.

Taiko nurodytą funkciją atitinkamiems dviejų sekų elementams, sukuriant rezultatų seką.

Įgalina užklausos lygiagretinimą.

Įgalina užklausos lygiagretinimą.

Pateikia elementų rinkinį, kuriame yra kiekvieno šaltinio rinkinio mazgo protėviai.

Pateikia filtruotą elementų rinkinį, kuriame yra kiekvieno šaltinio rinkinio mazgo protėviai. Į kolekciją įtraukiami tik tie elementai, kurie turi atitinkantį XName.

Pateikia kiekvieno šaltinio kolekcijos dokumento ir elemento palikuonių mazgų rinkinį.

Pateikia elementų rinkinį, kuriame yra kiekvieno šaltinio kolekcijos elemento ir dokumento palikuonių elementai.

Pateikia filtruotą elementų rinkinį, kuriame yra kiekvieno šaltinio kolekcijos elemento ir dokumento palikuonių elementai. Į kolekciją įtraukiami tik tie elementai, kurie turi atitinkantį XName.

Grąžina kiekvieno šaltinio kolekcijos elemento ir dokumento antrinių elementų rinkinį.

Pateikia filtruotą kiekvieno šaltinio kolekcijos elemento ir dokumento antrinių elementų rinkinį. Į kolekciją įtraukiami tik tie elementai, kurie turi atitinkantį XName.

Pateikia mazgų rinkinį, kuriame yra visi šaltinio rinkinio mazgai, surūšiuoti pagal dokumentų tvarką.

Pateikia kiekvieno šaltinio rinkinio dokumento ir elemento antrinių mazgų rinkinį.


Agregatoriaus transformacija „Informatikoje“ su pavyzdžiu

Agregatoriaus transformacija yra aktyvi transformacija, naudojama atliekant suvestinius skaičiavimus, tokius kaip suma, vidurkis ir kt.

Pvz., Jei norite išmintingai apskaičiuoti visų darbuotojų atlyginimų sumą, galime naudoti „Aggregator Transformation“.

Apibendrinimo operacijos atliekamos per eilučių grupę, todėl norint išsaugoti visus šiuos įrašus ir atlikti skaičiavimus, reikia laikinos vietos rezervavimo ženklo.

Tam naudojama kaupiklio talpykla. Tai laikina pagrindinė atmintis, skirta agregatoriaus transformacijai atlikti tokias operacijas.

Šiame pavyzdyje išmintingai apskaičiuosime atlyginimų sumą. Tam reikalingas naujas stulpelis, kuriame bus saugoma ši suma. Taigi, visų pirma, paruošime naują skiltį.

1 žingsnis - Sukurkite naują duomenų bazės tikslinę lentelę, pvz., Pasakykite „sum_sal_deptwise“ naudodami toliau pateiktą scenarijų. Kitame žingsnyje pamatysite, kad nauja tikslinės duomenų bazės lentelė yra sukurta aplanke „Tikslas“.

2 žingsnis - Sukurkite naują žemėlapį „m_ sum_sal_deptwise“.

Kad sukurtume naują atvaizdavimą, mums reikia šaltinio lentelės (EMP) ir tikslinės lentelės (sum_sal_deptwise) tiek atvaizdavimo dizaineryje, kad turėtume

3 žingsnis - Žemėlapyje,

4 žingsnis - Nuvilkite SAL ir amp DEPTNO stulpelius iš šaltinio kvalifikatoriaus (SQ_EMP) į kaupiklio transformaciją

5 žingsnis - Dukart spustelėkite agregatoriaus transformaciją, kad atidarytumėte jo savybes, ir tada

6 žingsnis - Išraiškos lange

7 žingsnis - Redagavimo transformacijos lange pažymėkite parinktį „GroupBy“ pažymėdami žymimąjį laukelį prie stulpelio deptno ir spustelėkite Gerai (pažymėdami grupę prieš deptno, nurodome „Informatica“ grupuoti atlyginimus pagal deptno)

8 žingsnis - Susiekite stulpelius „deptno“ ir „sum_sal“ iš agregatoriaus transformacijos su tiksline lentele

Dabar išsaugokite žemėlapį ir vykdykite jį sukūrę naują šio susiejimo seansą. Tikslinėje lentelėje būtų nurodoma atlyginimų suma pagal skyrių. Tokiu būdu galime naudoti agregatoriaus transformaciją apskaičiuodami suvestinius rezultatus.


Surogatiniai raktai

According to the Webster’s Unabridged Dictionary, a surrogate is an “artificial or synthetic product that is used as a substitute for a natural product.” Thatýs a great definition for the surrogate keys we use in data warehouses. A surrogate key is an artificial or synthetic key that is used as a substitute for a natural key.

Actually, a surrogate key in a data warehouse is more than just a substitute for a natural key. In a data warehouse, a surrogate key is a necessary generalization of the natural production key and is one of the basic elements of data warehouse design. Let’s be very clear: Every join between dimension tables and fact tables in a data warehouse environment should be based on surrogate keys, not natural keys. It is up to the data extract logic to systematically look up and replace every incoming natural key with a data warehouse surrogate key each time either a dimension record or a fact record is brought into the data warehouse environment.

In other words, when we have a product dimension joined to a fact table, or a customer dimension joined to a fact table, or even a time dimension joined to a fact table, the actual physical keys on either end of the joins are not natural keys directly derived from the incoming data. Rather, the keys are surrogate keys that are just anonymous integers. Each one of these keys should be a simple integer, starting with one and going up to the highest number that is needed. The product key should be a simple integer, the customer key should be a simple integer, and even the time key should be a simple integer. None of the keys should be:

  • Smart, where you can tell something about the record just by looking at the key
  • Composed of natural keys glued together
  • Implemented as multiple parallel joins between the dimension table and the fact table so-called double or triple barreled joins.

If you are a professional DBA, I probably have your attention. If you are new to data warehousing, you are probably horrified. Perhaps you are saying, “But if I know what my underlying key is, all my training suggests that I make my key out of the data I am given.” Yes, in the production transaction processing environment, the meaning of a product key or a customer key is directly related to the record’s content. In the data warehouse environment, however, a dimension key must be a generalization of what is found in the record.

As the data warehouse manager, you need to keep your keys independent from the production keys. Production has different priorities from you. Production keys such as product keys or customer keys are generated, formatted, updated, deleted, recycled, and reused according to the dictates of production. If you use production keys as your keys, you will be jerked around by changes that can be, at the very least, annoying, and at the worst, disastrous. Suppose that you need to keep a three-year history of product sales in your large sales fact table, but production decides to purge their product file every 18 months. What do you do then? Let’s list some of the ways that production may step on your toes:

  • Production may reuse keys that it has purged but that you are still maintaining, as I described.
  • Production may make a mistake and reuse a key even when it isn’t supposed to. This happens frequently in the world of UPCs in the retail world, despite everyone’s best intentions.
  • Production may re-compact its key space because it has a need to garbage-collect the production system. One of my customers was recently handed a data warehouse load tape with all the production customer keys reassigned!
  • Production may legitimately overwrite some part of a product description or a customer description with new values but not change the product key or the customer key to a new value. You are left holding the bag and wondering what to do about the revised attribute values. This is the Slowly Changing Dimension crisis, which I will explain in a moment.
  • Production may generalize its key format to handle some new situation in the transaction system. Now the production keys that used to be integers become alphanumeric. Or perhaps the 12-byte keys you are used to have become 20-byte keys.
  • Your company has just made an acquisition, and you need to merge more than a million new customers into the master customer list. You will now need to extract from two production systems, but the newly acquired production system has nasty customer keys that don’t look remotely like the others.

The Slowly Changing Dimension crisis I mentioned earlier is a well-known situation in data warehousing. Rather than blaming production for not handling its keys better, it is more constructive to recognize that this is an area where the interests of production and the interests of the data warehouse legitimately diverge. Usually, when the data warehouse administrator encounters a changed description in a dimension record such as product or customer, the correct response is to issue a new dimension record. But to do this, the data warehouse must have a more general key structure. Hence the need for a surrogate key.

There are still more reasons to use surrogate keys. One of the most important is the need to encode uncertain knowledge. You may need to supply a customer key to represent a transaction, but perhaps you donýt know for certain who the customer is. This would be a common occurrence in a retail situation where cash transactions are anonymous, like most grocery stores. What is the customer key for the anonymous customer? Perhaps you have introduced a special key that stands for this anonymous customer. This is politely referred to as a “hack.”

If you think carefully about the “I don’t know” situation, you may want more than just this one special key for the anonymous customer. You may also want to describe the situation where “the customer identification has not taken place yet.” Or maybe, “there was a customer, but the data processing system failed to report it correctly.” And also, “no customer is possible in this situation.” All of these situations call for a data warehouse customer key that cannot be composed from the transaction production customer keys. Don’t forget that in the data warehouse you must provide a customer key for every fact record in the schema shown in Figure 1. A null key automatically turns on the referential integrity alarm in your data warehouse because a foreign key (as in the fact table) can never be null.

The “I don’t know” situation occurs quite frequently for dates. You are probably using date-valued keys for your joins between your fact tables and your dimension tables. Once again, if you have done this you are forced to use some kind of real date to represent the special situations where a date value is not possible. I hope you have not been using January 1, 2000 to stand for “I don’t know.” If you have done this, you have managed to combine the production key crisis with the Year 2000 crisis.

Maybe one of the reasons you are holding on to your smart keys built up out of real data is that you think you want to navigate the keys directly with an application, avoiding the join to the dimension table. It is time to forget this strategy. If the fifth through ninth alpha characters in the join key can be interpreted as a manufacturer’s ID, then copy these characters and make them a normal field in the dimension table. Better yet, add the manufacturer’s name in plain text as a field. As the final step, consider throwing away the alphanumeric manufacturer ID. The only reason the marketing end users know these IDs is that they have been forced to use them for computer requests.

Holding onto real date values as keys is also a strategic blunder. Yes, you can navigate date keys with straight SQL, thereby avoiding the join, but you have left all your special calendar information marooned in the date dimension table. If you navigate naked date keys with an application, you will inevitably begin embedding calendar logic in your application. Calendar logic belongs in a dimension table, not in your application code.

You may be able to save substantial storage space with integer-valued surrogate keys. Suppose you have a big fact table with a billion rows of data. In such a table, every byte wasted in each row is a gigabyte of total storage. The beauty of a four-byte integer key is that it can represent more than 2 billion different values. That is enough for any dimension, even the so-called monster dimensions that represent individual human beings. So we compress all our long customer IDs and all our long product stock keeping units and all our date stamps down to four-byte keys. This saves many gigabytes of total storage.

The final reason I can think of for surrogate keys is one that I strongly suspect but have never proven. Replacing big, ugly natural keys and composite keys with beautiful, tight integer surrogate keys is bound to improve join performance. The storage requirements are reduced, and the index lookups would seem to be simpler. I would be interested in hearing from anyone who has harvested a performance boost by replacing big ugly fat keys with anonymous integer keys.

Having made the case for surrogate keys, we now are faced with creating them. Fundamentally, every time we see a natural key in the incoming data stream, we must look up the correct value of the surrogate key and replace the natural key with the surrogate key. Because this is a significant step in the daily extract and transform process within the data staging area, we need to tighten down our techniques to make this lookup simple and fast.


Transform

transform, metamorphose, transmute, convert, transmogrify, transfigure mean to change a thing into a different thing. transform implies a major change in form, nature, or function. transformed a small company into a corporate giant metamorphose suggests an abrupt or startling change induced by or as if by magic or a supernatural power. awkward girls metamorphosed into graceful ballerinas transmute implies transforming into a higher element or thing. attempted to transmute lead into gold convert implies a change fitting something for a new or different use or function. converted the study into a nursery transmogrify suggests a strange or preposterous metamorphosis. a story in which a frog is transmogrified into a prince transfigure implies a change that exalts or glorifies. joy transfigured her face


About the Author

Siddharth Teotia is a software engineer at Dremio and a contributor to Apache Arrow project. Previously, Siddharth was on the database kernel team at Oracle, where he worked on storage, indexing, and the in-memory columnar query processing layers of Oracle RDBMS. He holds an MS in software engineering from CMU and a BS in information systems from BITS Pilani, India. During his studies, Siddharth focused on distributed systems, databases, and software architecture.


Turinys

The first part of an ETL process involves extracting the data from the source system(s). In many cases, this represents the most important aspect of ETL, since extracting data correctly sets the stage for the success of subsequent processes. Most data-warehousing projects combine data from different source systems. Each separate system may also use a different data organization and/or format. Common data-source formats include relational databases, XML, JSON and flat files, but may also include non-relational database structures such as Information Management System (IMS) or other data structures such as Virtual Storage Access Method (VSAM) or Indexed Sequential Access Method (ISAM), or even formats fetched from outside sources by means such as web spidering or screen-scraping. The streaming of the extracted data source and loading on-the-fly to the destination database is another way of performing ETL when no intermediate data storage is required.

An intrinsic part of the extraction involves data validation to confirm whether the data pulled from the sources has the correct/expected values in a given domain (such as a pattern/default or list of values). If the data fails the validation rules, it is rejected entirely or in part. The rejected data is ideally reported back to the source system for further analysis to identify and to rectify the incorrect records.

In the data transformation stage, a series of rules or functions are applied to the extracted data in order to prepare it for loading into the end target.

An important function of transformation is data cleansing, which aims to pass only "proper" data to the target. The challenge when different systems interact is in the relevant systems' interfacing and communicating. Character sets that may be available in one system may not be so in others.

In other cases, one or more of the following transformation types may be required to meet the business and technical needs of the server or data warehouse:

  • Selecting only certain columns to load: (or selecting null columns not to load). For example, if the source data has three columns (aka "attributes"), roll_no, age, and salary, then the selection may take only roll_no and salary. Or, the selection mechanism may ignore all those records where salary is not present (salary = null).
  • Translating coded values: (pvz., if the source system codes male as "1" and female as "2", but the warehouse codes male as "M" and female as "F")
  • Encoding free-form values: (pvz., mapping "Male" to "M")
  • Deriving a new calculated value: (pvz., sale_amount = qty * unit_price)
  • Sorting or ordering the data based on a list of columns to improve search performance data from multiple sources (pvz., lookup, merge) and deduplicating the data
  • Aggregating (for example, rollup — summarizing multiple rows of data — total sales for each store, and for each region, etc.)
  • Generating surrogate-key values or pivoting (turning multiple columns into multiple rows or vice versa)
  • Splitting a column into multiple columns (pvz., converting a comma-separated list, specified as a string in one column, into individual values in different columns)
  • Disaggregating repeating columns
  • Looking up and validating the relevant data from tables or referential files
  • Applying any form of data validation failed validation may result in a full rejection of the data, partial rejection, or no rejection at all, and thus none, some, or all of the data is handed over to the next step depending on the rule design and exception handling many of the above transformations may result in exceptions, e.g., when a code translation parses an unknown code in the extracted data

The load phase loads the data into the end target, which can be any data store including a simple delimited flat file or a data warehouse. [5] Depending on the requirements of the organization, this process varies widely. Some data warehouses may overwrite existing information with cumulative information updating extracted data is frequently done on a daily, weekly, or monthly basis. Other data warehouses (or even other parts of the same data warehouse) may add new data in a historical form at regular intervals — for example, hourly. To understand this, consider a data warehouse that is required to maintain sales records of the last year. This data warehouse overwrites any data older than a year with newer data. However, the entry of data for any one year window is made in a historical manner. The timing and scope to replace or append are strategic design choices dependent on the time available and the business needs. More complex systems can maintain a history and audit trail of all changes to the data loaded in the data warehouse. [6]

As the load phase interacts with a database, the constraints defined in the database schema — as well as in triggers activated upon data load — apply (for example, uniqueness, referential integrity, mandatory fields), which also contribute to the overall data quality performance of the ETL process.

  • For example, a financial institution might have information on a customer in several departments and each department might have that customer's information listed in a different way. The membership department might list the customer by name, whereas the accounting department might list the customer by number. ETL can bundle all of these data elements and consolidate them into a uniform presentation, such as for storing in a database or data warehouse.
  • Another way that companies use ETL is to move information to another application permanently. For instance, the new application might use another database vendor and most likely a very different database schema. ETL can be used to transform the data into a format suitable for the new application to use.
  • An example would be an Expense and Cost Recovery System (ECRS) such as used by accountancies, consultancies, and legal firms. The data usually ends up in the time and billing system, although some businesses may also utilize the raw data for employee productivity reports to Human Resources (personnel dept.) or equipment usage reports to Facilities Management.

The typical real-life ETL cycle consists of the following execution steps:

  1. Cycle initiation
  2. Build reference data
  3. Extract (from sources)
  4. Transform (clean, apply business rules, check for data integrity, create aggregates or disaggregates)
  5. Stage (load into staging tables, if used) (for example, on compliance with business rules. Also, in case of failure, helps to diagnose/repair)
  6. Publish (to target tables)

ETL processes can involve considerable complexity, and significant operational problems can occur with improperly designed ETL systems.

The range of data values or data quality in an operational system may exceed the expectations of designers at the time validation and transformation rules are specified. Data profiling of a source during data analysis can identify the data conditions that must be managed by transform rules specifications, leading to an amendment of validation rules explicitly and implicitly implemented in the ETL process.

Data warehouses are typically assembled from a variety of data sources with different formats and purposes. As such, ETL is a key process to bring all the data together in a standard, homogeneous environment.

Design analysis [7] should establish the scalability of an ETL system across the lifetime of its usage — including understanding the volumes of data that must be processed within service level agreements. The time available to extract from source systems may change, which may mean the same amount of data may have to be processed in less time. Some ETL systems have to scale to process terabytes of data to update data warehouses with tens of terabytes of data. Increasing volumes of data may require designs that can scale from daily batch to multiple-day micro batch to integration with message queues or real-time change-data-capture for continuous transformation and update.

ETL vendors benchmark their record-systems at multiple TB (terabytes) per hour (or

1 GB per second) using powerful servers with multiple CPUs, multiple hard drives, multiple gigabit-network connections, and much memory.

In real life, the slowest part of an ETL process usually occurs in the database load phase. Databases may perform slowly because they have to take care of concurrency, integrity maintenance, and indices. Thus, for better performance, it may make sense to employ:

  • Direct path extract method or bulk unload whenever is possible (instead of querying the database) to reduce the load on source system while getting high-speed extract
  • Most of the transformation processing outside of the database
  • Bulk load operations whenever possible

Still, even using bulk operations, database access is usually the bottleneck in the ETL process. Some common methods used to increase performance are:

    tables (and indices): try to keep partitions similar in size (watch for null values that can skew the partitioning)
  • Do all validation in the ETL layer before the load: disable integrity checking ( disable constraint . ) in the target database tables during the load
  • Disable triggers ( disable trigger . ) in the target database tables during the load: simulate their effect as a separate step
  • Generate IDs in the ETL layer (not in the database)
  • Drop the indices (on a table or partition) before the load - and recreate them after the load (SQL: drop index . create index . )
  • Use parallel bulk load when possible — works well when the table is partitioned or there are no indices (Note: attempting to do parallel loads into the same table (partition) usually causes locks — if not on the data rows, then on indices)
  • If a requirement exists to do insertions, updates, or deletions, find out which rows should be processed in which way in the ETL layer, and then process these three operations in the database separately you often can do bulk load for inserts, but updates and deletes commonly go through an API (using SQL)

Whether to do certain operations in the database or outside may involve a trade-off. For example, removing duplicates using distinct may be slow in the database thus, it makes sense to do it outside. On the other side, if using distinct significantly (x100) decreases the number of rows to be extracted, then it makes sense to remove duplications as early as possible in the database before unloading data.

A common source of problems in ETL is a big number of dependencies among ETL jobs. For example, job "B" cannot start while job "A" is not finished. One can usually achieve better performance by visualizing all processes on a graph, and trying to reduce the graph making maximum use of parallelism, and making "chains" of consecutive processing as short as possible. Again, partitioning of big tables and their indices can really help.

Another common issue occurs when the data are spread among several databases, and processing is done in those databases sequentially. Sometimes database replication may be involved as a method of copying data between databases — it can significantly slow down the whole process. The common solution is to reduce the processing graph to only three layers:

This approach allows processing to take maximum advantage of parallelism. For example, if you need to load data into two databases, you can run the loads in parallel (instead of loading into the first — and then replicating into the second).

Sometimes processing must take place sequentially. For example, dimensional (reference) data are needed before one can get and validate the rows for main "fact" tables.

A recent [update] development in ETL software is the implementation of parallel processing. It has enabled a number of methods to improve overall performance of ETL when dealing with large volumes of data.

ETL applications implement three main types of parallelism:

  • Data: By splitting a single sequential file into smaller data files to provide parallel access : allowing the simultaneous running of several components on the same data stream, e.g. looking up a value on record 1 at the same time as adding two fields on record 2
  • Component: The simultaneous running of multiple processes on different data streams in the same job, e.g. sorting one input file while removing duplicates on another file

All three types of parallelism usually operate combined in a single job or task.

An additional difficulty comes with making sure that the data being uploaded is relatively consistent. Because multiple source databases may have different update cycles (some may be updated every few minutes, while others may take days or weeks), an ETL system may be required to hold back certain data until all sources are synchronized. Likewise, where a warehouse may have to be reconciled to the contents in a source system or with the general ledger, establishing synchronization and reconciliation points becomes necessary.

Data warehousing procedures usually subdivide a big ETL process into smaller pieces running sequentially or in parallel. To keep track of data flows, it makes sense to tag each data row with "row_id", and tag each piece of the process with "run_id". In case of a failure, having these IDs help to roll back and rerun the failed piece.

Best practice also calls for checkpoints, which are states when certain phases of the process are completed. Once at a checkpoint, it is a good idea to write everything to disk, clean out some temporary files, log the state, etc.

As of 2010 [update] , data virtualization had begun to advance ETL processing. The application of data virtualization to ETL allowed solving the most common ETL tasks of data migration and application integration for multiple dispersed data sources. Virtual ETL operates with the abstracted representation of the objects or entities gathered from the variety of relational, semi-structured, and unstructured data sources. ETL tools can leverage object-oriented modeling and work with entities' representations persistently stored in a centrally located hub-and-spoke architecture. Such a collection that contains representations of the entities or objects gathered from the data sources for ETL processing is called a metadata repository and it can reside in memory [8] or be made persistent. By using a persistent metadata repository, ETL tools can transition from one-time projects to persistent middleware, performing data harmonization and data profiling consistently and in near-real time. [9]

Unique keys play an important part in all relational databases, as they tie everything together. A unique key is a column that identifies a given entity, whereas a foreign key is a column in another table that refers to a primary key. Keys can comprise several columns, in which case they are composite keys. In many cases, the primary key is an auto-generated integer that has no meaning for the business entity being represented, but solely exists for the purpose of the relational database - commonly referred to as a surrogate key.

As there is usually more than one data source getting loaded into the warehouse, the keys are an important concern to be addressed. For example: customers might be represented in several data sources, with their Social Security Number as the primary key in one source, their phone number in another, and a surrogate in the third. Yet a data warehouse may require the consolidation of all the customer information into one dimension.

A recommended way to deal with the concern involves adding a warehouse surrogate key, which is used as a foreign key from the fact table. [10]

Usually, updates occur to a dimension's source data, which obviously must be reflected in the data warehouse.

If the primary key of the source data is required for reporting, the dimension already contains that piece of information for each row. If the source data uses a surrogate key, the warehouse must keep track of it even though it is never used in queries or reports it is done by creating a lookup table that contains the warehouse surrogate key and the originating key. [11] This way, the dimension is not polluted with surrogates from various source systems, while the ability to update is preserved.

The lookup table is used in different ways depending on the nature of the source data. There are 5 types to consider [11] three are included here:

Type 1 The dimension row is simply updated to match the current state of the source system the warehouse does not capture history the lookup table is used to identify the dimension row to update or overwrite Type 2 A new dimension row is added with the new state of the source system a new surrogate key is assigned source key is no longer unique in the lookup table Fully logged A new dimension row is added with the new state of the source system, while the previous dimension row is updated to reflect it is no longer active and time of deactivation.

By using an established ETL framework, one may increase one's chances of ending up with better connectivity and scalability. [ reikalinga citata ] A good ETL tool must be able to communicate with the many different relational databases and read the various file formats used throughout an organization. ETL tools have started to migrate into Enterprise Application Integration, or even Enterprise Service Bus, systems that now cover much more than just the extraction, transformation, and loading of data. Many ETL vendors now have data profiling, data quality, and metadata capabilities. A common use case for ETL tools include converting CSV files to formats readable by relational databases. A typical translation of millions of records is facilitated by ETL tools that enable users to input csv-like data feeds/files and import it into a database with as little code as possible.

ETL tools are typically used by a broad range of professionals — from students in computer science looking to quickly import large data sets to database architects in charge of company account management, ETL tools have become a convenient tool that can be relied on to get maximum performance. ETL tools in most cases contain a GUI that helps users conveniently transform data, using a visual data mapper, as opposed to writing large programs to parse files and modify data types.

While ETL tools have traditionally been for developers and IT staff, the new trend is to provide these capabilities to business users so they can themselves create connections and data integrations when needed, rather than going to the IT staff. [12] Gartner refers to these non-technical users as Citizen Integrators. [13]

Extract, load, transform (ELT) is a variant of ETL where the extracted data is loaded into the target system first. [14] The architecture for the analytics pipeline shall also consider where to cleanse and enrich data [14] as well as how to conform dimensions. [4]

Cloud-based data warehouses like Amazon Redshift, Google BigQuery, and Snowflake Computing have been able to provide highly scalable computing power. This lets businesses forgo preload transformations and replicate raw data into their data warehouses, where it can transform them as needed using SQL.

After having used ELT, data may be processed further and stored in a data mart. [15]