Aféierung
Ech hunn dëse Bericht op Englesch op der GopherCon Russia 2019 Konferenz zu Moskau an op Russesch op engem Meetup zu Nizhny Novgorod ginn. Mir schwätzen iwwer e Bitmap Index - manner heefeg wéi B-Bam, awer net manner interessant. Deelen Rieden op der Konferenz op Englesch an Text Transkriptiounen op Russesch.
Mir wäerte kucken wéi e Bitmap Index funktionnéiert, wann et besser ass, wann et méi schlecht ass wéi aner Indexen, a wéi enge Fäll ass et wesentlech méi séier wéi si; Loosst eis kucken wéi eng populär DBMSs scho Bitmap-Index hunn; Loosst eis probéieren eis selwer am Go ze schreiwen. A "fir Dessert" wäerte mir fäerdeg Bibliothéike benotzen fir eis eege super-schnell spezialiséiert Datebank ze kreéieren.
Ech hoffen wierklech datt meng Wierker nëtzlech an interessant fir Iech sinn. Gitt!
Aféierung
Moien alleguer! Et ass sechs den Owend a mir sinn alleguer super midd. Flott Zäit fir iwwer langweileg Datebankindextheorie ze schwätzen, richteg? Maacht Iech keng Suergen, ech hunn e puer Zeilen Quellcode hei an do. 🙂
All Witzer ofgesinn, de Bericht ass voller Informatioun, a mir hunn net vill Zäit. Also loosst eis ufänken.
Haut wäert ech iwwer déi folgend schwätzen:
- wat sinn Indizes;
- wat ass e Bitmap Index;
- wou et benotzt gëtt a wou et NET benotzt gëtt a firwat;
- einfach Ëmsetzung am Go an e klenge Kampf mam Compiler;
- liicht manner einfach, awer vill méi produktiv Ëmsetzung am Go assembler;
- "Problemer" vun Bitmap Indexen;
- bestehend Implementatiounen.
Also wat sinn Indizes?
Den Index ass eng separat Datestruktur déi mir zousätzlech zu den Haaptdaten erhalen an aktualiséieren. Et gëtt benotzt fir d'Sich ze beschleunegen. Ouni Indexen, Sich géif erfuerderen d'Daten komplett duerchzegoen (e Prozess genannt Voll Scan), an dëse Prozess huet linear algorithmesch Komplexitéit. Awer Datenbanken enthalen normalerweis enorm Quantitéiten un Daten an d'linear Komplexitéit ass ze lues. Ideal kréie mir eng logarithmesch oder konstant.
Dëst ass en immens komplext Thema, gefüllt mat Subtilitéiten an Ofdreiwungen, awer nodeems ech Joerzéngte vun der Datebankentwécklung a Fuerschung gekuckt hunn, sinn ech gewëllt ze soen datt et nëmmen e puer wäit benotzt Approche fir Datebankindexen ze kreéieren.
Déi éischt Approche ass de Sichraum hierarchesch ze reduzéieren, de Sichraum a méi kleng Deeler opzedeelen.
Mir maachen dat normalerweis mat verschiddenen Aarte vu Beem. E Beispill wier eng grouss Këscht mat Materialien an Ärem Kleederschaf, déi méi kleng Këschte vu Materialien enthält, déi a verschidden Themen opgedeelt sinn. Wann Dir Material braucht, sicht Dir se wahrscheinlech an enger Këscht déi "Materialien" seet anstatt een deen "Cookies" seet, richteg?
Déi zweet Approche ass direkt de gewënschte Element oder Grupp vun Elementer ze wielen. Mir maachen dat an Hash Kaarten oder ëmgedréint Indexen. D'Benotzung vun Hashkaarten ass ganz ähnlech wéi dat viregt Beispill, awer amplaz vun enger Këscht vu Këschte, hutt Dir eng Rëtsch kleng Këschte mat endgültege Saachen an Ärem Kleederschaf.
Déi drëtt Approche ass de Besoin fir d'Sich ze eliminéieren. Mir maachen dat mat Bloom Filteren oder Kuckuckfilter. Déi éischt ginn eng Äntwert direkt, spuert Iech fir ze sichen.
Déi lescht Approche ass fir all d'Kraaft ze benotzen déi modern Hardware eis gëtt. Dëst ass genau wat mir an Bitmap Indexen maachen. Jo, wann Dir se benotzt, musse mir heiansdo de ganzen Index duerchgoen, awer mir maachen et super effizient.
Wéi ech gesot hunn, ass d'Thema vun den Datebankindexe grouss a voller Kompromëss. Dëst bedeit datt mir heiansdo verschidde Approche zur selwechter Zäit benotze kënnen: wa mir d'Sich nach méi séier musse beschleunegen, oder wa mir all méiglech Sichtypen mussen ofdecken.
Haut wäert ech iwwer déi mannst bekannt Approche vun dësen schwätzen - Bitmap Indexen.
Wien sinn ech fir iwwer dëst Thema ze schwätzen?
Ech schaffen als Teamleader bei Badoo (vläicht sidd Dir méi vertraut mat eisem anere Produkt, Bumble). Mir hu scho méi wéi 400 Millioune Benotzer ronderëm d'Welt a vill Funktiounen déi de beschte Match fir si wielen. Mir maachen dat mat personaliséierte Servicer, dorënner Bitmap Indexen.
Also wat ass e Bitmap Index?
Bitmap Indexen, wéi den Numm et scho seet, benotze Bitmaps oder Bitsets fir e Sichindex ëmzesetzen. Vun engem Vugelperspektiv besteet dësen Index aus engem oder méi esou Bitmaps, déi all Entitéite representéieren (wéi Leit) an hir Eegeschaften oder Parameteren (Alter, Aenfaarf, etc.), an engem Algorithmus mat Bitoperatiounen (AN, ODER, NET) ) fir d'Sichufro ze beäntweren.
Mir ginn gesot datt Bitmap-Indexe am Beschten passend sinn a ganz performant sinn fir Fäll wou et Sich sinn déi Ufroen iwwer vill Kolonnen mat niddereg Kardinalitéit kombinéieren (denkt "Aenfaarf" oder "Etat civil" versus eppes wéi "Distanz vum Stadzentrum"). Awer ech wäert spéider weisen datt se och gutt fir Kolonnen mat héije Kardinalitéit funktionnéieren.
Loosst eis dat einfachst Beispill vun engem Bitmap Index kucken.
Stellt Iech vir datt mir eng Lëscht vu Moskauer Restauranten mat binären Eegeschafte wéi dës hunn:
- bei Metro;
- et gëtt private Parking;
- et gëtt eng Veranda (mat Terrass);
- Dir kënnt en Dësch reservéieren (akzeptéiert Reservatiounen);
- gëeegent fir Vegetarier (vegan frëndlech);
- deier (deier).
Loosst eis all Restaurant eng Sequenznummer ginn déi vun 0 fänkt un an allokéiert Erënnerung fir 6 Bitmaps (eent fir all Charakteristik). Mir populéieren dann dës Bitmaps ofhängeg ob de Restaurant dës Immobilie huet oder net. Wann de Restaurant 4 eng Veranda huet, da gëtt Bit Nummer 4 am Bitmap "huet eng Veranda" op 1 gesat (wann et keng Veranda ass, dann op 0).
Elo hu mir den einfachsten Bitmap Index méiglech, a mir kënnen et benotze fir Ufroen ze beäntweren wéi:
- "Weis mir vegetaresch-frëndlech Restauranten";
- "Weist mir bëlleg Restauranten mat enger Veranda wou Dir en Dësch reservéiere kënnt."
Wéi? Loosst eis kucken. Déi éischt Demande ass ganz einfach. Alles wat mir maache mussen ass de "vegetaresch frëndlechen" Bitmap ze huelen an et an eng Lëscht vu Restauranten ëmzesetzen, deenen hir Stécker ausgesat sinn.
Déi zweet Ufro ass e bësse méi komplizéiert. Mir mussen d'NET Bitmap op der "deier" Bitmap benotzen fir eng Lëscht vun preiswerte Restauranten ze kréien, dann AN et mat der Bitmap "Kann ech en Dësch buchen" an AN d'Resultat mam Bitmap "et gëtt eng Veranda". Déi resultéierend Bitmap enthält eng Lëscht vun Etablissementer déi all eis Critèren entspriechen. An dësem Beispill ass dëst nëmmen de Yunost Restaurant.
Et gëtt vill Theorie involvéiert, awer maach der keng Suergen, mir gesinn de Code ganz geschwënn.
Wou ginn Bitmap Indexen benotzt?
Wann Dir Google Bitmap Indexen, 90% vun den Äntwerte wäerten op eng oder aner Manéier mat Oracle DB verbonne sinn. Awer aner DBMSen ënnerstëtzen wahrscheinlech och sou eng cool Saach, oder? Net wierklech.
Loosst eis d'Lëscht vun den Haaptverdächtegen duerchgoën.
MySQL ënnerstëtzt nach net Bitmap-Indexen, awer et gëtt e Virschlag proposéiert dës Optioun derbäi ze ginn ().
PostgreSQL ënnerstëtzt keng Bitmap-Indexen, awer benotzt einfach Bitmaps a Bitoperatiounen fir Sichresultater iwwer verschidde aner Indexen ze kombinéieren.
Tarantool huet Bitset Indexen an ënnerstëtzt einfach Recherchen op hinnen.
Redis huet einfach Bitfields) ouni d'Fäegkeet no hinnen ze sichen.
MongoDB ënnerstëtzt nach net Bitmap-Indexen, awer et gëtt och e Propos dee proposéiert datt dës Optioun derbäigesat gëtt
Elasticsearch benotzt Bitmaps intern).
- Awer en neien Noper ass an eisem Haus opgetaucht: Pilosa. Dëst ass eng nei net-relational Datebank geschriwwen am Go. Et enthält nëmmen Bitmap Indexen a baséiert alles op hinnen. Mir schwätzen iwwer et e bësse méi spéit.
Ëmsetzung an Go
Awer firwat ginn Bitmap Indexe sou selten benotzt? Ier Dir dës Fro beäntwert, wëll ech Iech weisen wéi Dir e ganz einfache Bitmap Index am Go implementéiert.
Bitmaps si wesentlech just Stécker vun Daten. Am Go, loosst eis Byte Slice fir dëst benotzen.
Mir hunn eng Bitmap fir ee Restaurant Charakteristik, an all Bit an der Bitmap weist ob e bestëmmte Restaurant dës Eegeschafte huet oder net.
Mir brauchen zwou Hëllefsfunktiounen. Ee gëtt benotzt fir eis Bitmaps mat zoufälleg Daten ze fëllen. Zoufälleg, awer mat enger gewësser Wahrscheinlechkeet datt de Restaurant all Propriétéit huet. Zum Beispill, Ech gleewen, datt et ganz wéineg Restauranten zu Moskau sinn, wou Dir net kann en Dësch reservéieren, an et schéngt fir mech, datt ongeféier 20% vun den Etablissementer fir Vegetarier gëeegent sinn.
Déi zweet Funktioun konvertéiert de Bitmap an eng Lëscht vu Restauranten.
Fir d'Ufro ze beäntweren "Weist mir preiswerte Restauranten déi eng Patio hunn a kënnen Reservatioune maachen", brauche mir zwee Bit Operatiounen: NET an AN.
Mir kënnen eise Code e bësse vereinfachen andeems Dir de méi komplexe AN NET Bedreiwer benotzt.
Mir hunn Funktiounen fir all eenzel vun dësen Operatiounen. Béid ginn duerch d'Scheiwen, huelen déi entspriechend Elementer vun all, kombinéieren se mat e bëssen Operatioun an setzen d'Resultat an d'entstinn Slice.
An elo kënne mir eis Bitmaps a Funktiounen benotzen fir d'Sichufro ze beäntweren.
D'Performance ass net sou héich, och wann d'Funktioune ganz einfach sinn a mir vill Sue gespuert hunn andeems mir keng nei resultéierend Slice zréckginn all Kéier wann d'Funktioun opgeruff gouf.
Nodeems ech e bësse Profiler mat pprof gemaach hunn, hunn ech gemierkt datt de Go Compiler eng ganz einfach awer ganz wichteg Optimisatioun fehlt: Funktioun Inlining.
D'Tatsaach ass datt de Go Compiler schrecklech Angscht huet fir Schleifen déi duerch Slice goen, a refuséiert kategoresch inline Funktiounen déi esou Schleifen enthalen.
Awer ech fäerten net an ech kann de Compiler narren andeems ech goto benotzen anstatt eng Loop, wéi an de gudden alen Deeg.
A wéi Dir kënnt gesinn, elo wäert de Compiler eis Funktioun glécklech inline! Als Resultat gelénge mir ongeféier 2 Mikrosekonnen ze spueren. Net schlecht!
Den zweeten Flaschenhals ass einfach ze gesinn wann Dir d'Versammlungsausgang genau kuckt. De Compiler huet e Slice Grenzkontrolle direkt an eiser wäermst Loop bäigefüügt. De Fakt ass datt Go eng sécher Sprooch ass, de Compiler huet Angscht datt meng dräi Argumenter (dräi Scheiwen) vu verschiddene Gréissten sinn. No all, da gëtt et eng theoretesch Méiglechkeet vun der Optriede vun engem sougenannte Puffer Iwwerschwemmung.
Loosst eis de Compiler berouegen andeems Dir et weist datt all Scheiwen déiselwecht Gréisst sinn. Mir kënnen dat maachen andeems Dir en einfache Scheck am Ufank vun eiser Funktioun bäidréit.
Wann Dir dëst gesinn, spréngt de Compiler glécklech de Scheck, a mir spueren um Enn nach 500 Nanosekonnen.
Grouss Butzen
Okay, mir hunn et fäerdeg bruecht e bësse Leeschtung aus eiser einfacher Ëmsetzung ze pressen, awer dëst Resultat ass tatsächlech vill méi schlecht wéi méiglech mat aktueller Hardware.
Alles wat mir maachen ass Basis Bit Operatiounen, an eis Prozessoren maachen se ganz effizient. Mee, leider, mir "fidderen" eise Prozessor mat ganz kleng Stécker vun Aarbecht. Eis Funktiounen maachen Operatiounen op Byte-by-Byte Basis. Mir kënnen eise Code ganz einfach upassen fir mat 8-Byte Stécker mat UInt64 Slices ze schaffen.
Wéi Dir gesitt, huet dës kleng Ännerung eise Programm aacht Mol beschleunegt andeems d'Batchgréisst ëm aacht Mol eropgeet. De Gewënn kann linear gesot ginn.
Ëmsetzung an assembler
Mä dëst ass net d'Enn. Eis Prozessoren kënne mat Stécker vu 16, 32 a souguer 64 Bytes schaffen. Esou "breet" Operatiounen ginn eenzel Instruktioune Multiple Date genannt (SIMD; eng Instruktioun, vill Donnéeën), an de Prozess fir Code ze transforméieren sou datt et esou Operatiounen benotzt gëtt Vektoriséierung genannt.
Leider ass de Go Compiler wäit vun exzellent bei Vektoriséierung. De Moment ass deen eenzege Wee fir de Go Code ze vektoriséieren ass dës Operatiounen manuell mat Go Assembler ze huelen an ze setzen.
Go assembler ass e komescht Béischt. Dir wësst wahrscheinlech datt d'Assemblée Sprooch eppes ass wat staark mat der Architektur vum Computer gebonnen ass fir deen Dir schreift, awer dat ass net de Fall am Go. Go Assembler ass méi wéi eng IRL (Intermediate Representation Language) oder Mëttelstuf Sprooch: et ass praktesch Plattform onofhängeg. De Rob Pike huet eng exzellent Leeschtung gemaach iwwer dëst Thema virun e puer Joer op GopherCon zu Denver.
Zousätzlech benotzt Go en ongewéinleche Plan 9 Format, wat sech vun den allgemeng akzeptéierten AT&T an Intel Formater ënnerscheet.
Et ass sécher ze soen datt de Go assembler mat der Hand schreiwen ass net am meeschte Spaass.
Awer, glécklecherweis, ginn et schonn zwee High-Level Tools déi eis hëllefen Go assembler ze schreiwen: PeachPy an avo. Béid Utilities generéieren Go Assembler aus méi héije Code geschriwwen am Python a Go, respektiv.
Dës Utilitys vereinfachen Saachen wéi d'Registréierungsallokatioun, Schreiwen Schleifen, a vereinfachen allgemeng de Prozess fir an d'Welt vun der Assembléeprogramméierung am Go ze kommen.
Mir wäerten avo benotzen, sou datt eis Programmer bal regelméisseg Go Programmer sinn.
Dëst ass wéi dat einfachst Beispill vun engem avo Programm ausgesäit. Mir hunn eng Haaptfunktioun () déi a sech selwer d'Add () Funktioun definéiert, d'Bedeitung vun där ass zwou Zuelen derbäi ze ginn. Et gi Helperfunktiounen hei fir Parameteren mam Numm ze kréien an ee vun de gratis a gëeegente Prozessorregisteren ze kréien. All Prozessor Operatioun huet eng entspriechend Funktioun op avo, wéi an ADDQ gesinn. Endlech gesi mir eng Helperfunktioun fir de resultéierende Wäert ze späicheren.
Andeems Dir go generéiere rufft, wäerte mir de Programm op avo ausféieren an als Resultat ginn zwou Dateien generéiert:
- add.s mam resultéierende Code am Go assembler;
- stub.go mat Funktioun Header déi zwou Welten ze verbannen: Go an assembler.
Elo datt mir gesinn hunn wat avo mécht a wéi, loosst eis eis Funktiounen kucken. Ech hunn souwuel scalar wéi och vektor (SIMD) Versioune vun de Funktiounen ëmgesat.
Loosst eis d'Skalar Versiounen als éischt kucken.
Wéi am virege Beispill froe mir fir e gratis a valabel allgemeng Zweck Register, mir brauche keng Offsets a Gréisste fir d'Argumenter ze berechnen. avo mécht dat alles fir eis.
Mir hu fréier Etiketten a Goto (oder Spréng) benotzt fir d'Performance ze verbesseren an de Go Compiler ze tricken, awer elo maache mir et vun Ufank un. De Punkt ass datt Zyklen e méi héije Konzept sinn. Am Assembler hu mir nëmmen Etiketten a spréngt.
De Rescht Code soll scho vertraut a verständlech sinn. Mir emuléieren eng Loop mat Etiketten a Sprangen, huelen e klengt Stéck Daten aus eisen zwee Scheiwen, kombinéieren se mat e bëssen Operatioun (AN NET an dësem Fall) a setzen dann d'Resultat an déi resultéierend Slice. All.
Dëst ass wéi de finalen Assembler Code ausgesäit. Mir hu keng Offsets a Gréissten (gréng markéiert) berechent oder d'Registere verfollegt déi benotzt goufen (rout markéiert).
Wa mir d'Performance vun der Assemblée Sproochimplementatioun mat der Leeschtung vun der beschter Implementatioun am Go vergläichen, wäerte mir gesinn datt et d'selwecht ass. An dat gëtt erwaart. Iwwerhaapt hu mir näischt Besonnesches gemaach - mir hu just reproduzéiert wat e Go Compiler géif maachen.
Leider kënne mir de Compiler net forcéieren fir eis Funktiounen an der Assemblée Sprooch ze inline. De Go Compiler huet de Moment keng sou eng Feature, obwuel et eng Ufro gouf fir et zanter enger laanger Zäit ze addéieren.
Dofir ass et onméiglech fir e Virdeel vu klenge Funktiounen an der Assembléesprooch ze kréien. Mir mussen entweder grouss Funktiounen schreiwen, oder den neie Mathematik / Bits Package benotzen, oder d'Assembler Sprooch ëmgoen.
Loosst eis elo d'Vektorversioune vun eise Funktiounen kucken.
Fir dëst Beispill hunn ech decidéiert AVX2 ze benotzen, also wäerte mir Operatiounen benotzen déi op 32-Byte Stécker funktionnéieren. D'Struktur vum Code ass ganz ähnlech wéi d'Skalar Versioun: Luede Parameteren, froen fir e gratis gemeinsame Register, etc.
Eng Innovatioun ass datt méi breet Vektoroperatiounen speziell breet Registere benotzen. Am Fall vun 32-Byte Stécker sinn dës Registere mat Y. Dofir gesitt Dir d'YMM () Funktioun am Code. Wann ech den AVX-512 mat 64-Bit Stécker benotzt, wier de Präfix Z.
Déi zweet Innovatioun ass datt ech beschloss hunn eng Optimisatioun ze benotzen genannt Loop Unrolling, dat heescht aacht Loopoperatioune manuell ze maachen ier ech op den Ufank vun der Loop sprangen. Dës Optimiséierung reduzéiert d'Zuel vun de Filialen am Code, a gëtt limitéiert duerch d'Zuel vun de gratis Registere verfügbar.
Ee, wat iwwer Leeschtung? Si ass schéin! Mir hunn eng Geschwindegkeet vun ongeféier siwe Mol erreecht am Verglach mat der beschter Go Léisung. Impressionant, richteg?
Awer och dës Implementatioun kéint potenziell beschleunegt ginn andeems Dir AVX-512 benotzt, Prefetching oder e JIT (just-in-time Compiler) fir den Ufro Scheduler. Awer dëst ass sécherlech en Thema fir e separaten Bericht.
Problemer mat Bitmap Indexen
Elo datt mir schonn eng einfach Implementatioun vun engem Bitmap Index am Go an e vill méi produktiven an der Assemblée Sprooch gekuckt hunn, loosst eis endlech iwwer schwätzen firwat Bitmap Indexe sou selten benotzt ginn.
Eeler Pabeieren ernimmen dräi Probleemer mat Bitmap Indexen, awer méi nei Pabeieren an ech plädéieren datt se net méi relevant sinn. Mir wäerten net déif an all eenzel vun dëse Problemer dauchen, mee wäerte se iwwerflächlech kucken.
De Problem vun héich Kardinalitéit
Also, mir ginn gesot datt Bitmap-Indexen nëmme gëeegent sinn fir Felder mat gerénger Kardinalitéit, dat heescht déi, déi wéineg Wäerter hunn (zum Beispill Geschlecht oder Aenfaarf), an de Grond ass datt déi üblech Representatioun vun esou Felder (eent) Bit pro Wäert) am Fall vun héijer Kardinalitéit wäert et ze vill Plaz ophuelen an zousätzlech wäerten dës Bitmap-Indexe schlecht (selten) gefëllt sinn.
Heiansdo kënne mir eng aner Representatioun benotzen, sou wéi déi Standard déi mir benotze fir Zuelen ze representéieren. Awer et war d'Entstoe vu Kompressiounsalgorithmen déi alles geännert hunn. An de leschte Joerzéngte sinn d'Wëssenschaftler a Fuerscher mat enger grousser Zuel vu Kompressiounsalgorithmen fir Bitmaps komm. Hiren Haaptvirdeel ass datt et net néideg ass Bitmaps ze dekompriméieren fir Bitoperatiounen auszeféieren - mir kënnen Bitoperatiounen direkt op kompriméierte Bitmaps ausféieren.
Viru kuerzem sinn Hybrid Approche ugefaang ze erschéngen, sou wéi brëllend Bitmaps. Si benotzen gläichzäiteg dräi verschidde Representatioune fir Bitmaps - Bitmaps selwer, Arrays a sougenannte Bit Runs - a Balance tëscht hinnen fir d'Performance ze maximéieren an d'Erënnerungsverbrauch ze minimiséieren.
Dir kënnt roaring Bitmaps an de populäersten Uwendungen fannen. Et gi schonn eng riesech Unzuel vun Implementatiounen fir eng breet Varietéit vu Programméierungssproochen, dorënner méi wéi dräi Implementatioune fir Go.
Eng aner Approche déi eis hëllefe mat héijer Kardinalitéit ze këmmeren ass Binning genannt. Stellt Iech vir, Dir hutt e Feld deen d'Héicht vun enger Persoun representéiert. Héicht ass eng schwiewend Punktzuel, awer mir Mënschen denken net esou un. Fir eis gëtt et keen Ënnerscheed tëscht Héicht 185,2 cm an 185,3 cm.
Et stellt sech eraus datt mir ähnlech Wäerter a Gruppen bannent 1 cm gruppéiere kënnen.
A wa mir och wëssen, datt ganz wéineg Leit méi kuerz wéi 50 cm a méi grouss wéi 250 cm sinn, da kënne mir am Fong vun engem Feld mat onendlecher Kardinalitéit an e Feld mat enger Kardinalitéit vu ronn 200 Wäerter ëmsetzen.
Natierlech, wann néideg, kënne mir duerno zousätzlech Filteren maachen.
Héich Bandwidth Problem
Den nächste Problem mat Bitmap Indexen ass datt d'Aktualiséierung vun hinnen ganz deier ka sinn.
D'Datebase musse fäeg sinn Daten ze aktualiséieren wärend potenziell Honnerte vun anere Ufroe d'Donnéeën sichen. Mir brauche Spären fir Problemer mat gläichzäiteg Datezougang oder aner Deeleproblemer ze vermeiden. A wou et eng grouss Spär ass, gëtt et e Problem - Spär Sträit, wann dës Spär gëtt eng Flaschenhals.
Dëse Problem kann geléist oder ëmginn ginn andeems Dir Sharding benotzt oder Versiounsindexe benotzt.
Sharding ass eng einfach a bekannt Saach. Dir kënnt e Bitmap Index zerstéieren wéi Dir all aner Donnéeën hätt. Amplaz vun enger grousser Spär, kritt Dir eng Rëtsch kleng Spären an domat vun Spär Sträit lass.
Déi zweet Manéier fir de Problem ze léisen ass d'Versiounsindexe ze benotzen. Dir kënnt eng Kopie vum Index hunn, deen Dir benotzt fir ze sichen oder ze liesen, an eng Kopie déi Dir benotzt fir ze schreiwen oder ze aktualiséieren. An eemol an enger bestëmmter Zäit (zum Beispill, eemol all 100 MS oder 500 MS) duplizéiert Dir se an tauscht se. Natierlech ass dës Approche nëmmen applicabel a Fäll wou Är Applikatioun e liicht lagging Sichindex handhaben kann.
Dës zwou Approche kënne gläichzäiteg benotzt ginn: Dir kënnt e geschniddene Versiounsindex hunn.
Méi komplex Ufroen
De leschte Problem mat Bitmap-Indexen ass datt mir gesot ginn datt se net gutt passend sinn fir méi komplex Aarte vu Ufroen, wéi Spann-Ufroen.
Tatsächlech, wann Dir driwwer denkt, Bitoperatioune wéi AND, ODER, asw.
Eng naiv a ganz onkloer Léisung wier d'Resultater fir all Dollarwäert ze huelen an se mat enger bitwise ODER Operatioun ze kombinéieren.
Eng liicht besser Léisung wier d'Gruppéierung ze benotzen. Zum Beispill, a Gruppen vun 50 Dollar. Dëst géif eise Prozess ëm 50 Mol beschleunegen.
Awer de Problem ass och einfach geléist andeems Dir eng Vue benotzt, déi speziell fir dës Zort Ufro erstallt gouf. A wëssenschaftleche Pabeieren gëtt et Range-encodéiert Bitmaps genannt.
An dëser Representatioun setzen mir net nëmmen e bësse fir e Wäert (zum Beispill 200), mee setzen dëse Wäert an alles méi héich. 200 a méi héich. Selwecht fir 300:300 a méi. A sou weider.
Mat dëser Representatioun kënne mir dës Aart vu Sichufro beäntweren andeems Dir den Index just zweemol duerchkreest. Als éischt wäerte mir eng Lëscht vun Hoteler kréien, wou de Sall manner oder $ 300 kascht, an da wäerte mir déi ewechhuelen, wou de Raum manner kascht oder $ 199. Fäerdeg.
Dir wäert iwwerrascht sinn, awer och Geoqueries si méiglech mat Bitmap Indexen. Den Trick ass eng geometresch Representatioun ze benotzen déi Är Koordinat mat enger geometrescher Figur ëmginn. Zum Beispill, S2 vu Google. D'Figur soll méiglech sinn an der Form vun dräi oder méi Kräizung Linnen ze representéieren, déi nummeréiert kënne ginn. Op dës Manéier kënne mir eis Geoquery a verschidde Ufroen ëmsetzen "langs the gap" (laanscht dës nummeréiert Linnen).
Ready Solutions
Ech hoffen ech interesséiert Iech e bëssen an Dir hutt elo en anert nëtzlecht Tool an Ärem Arsenal. Wann Dir jeemools esou eppes maache musst, wësst Dir wéi ee kuckt.
Wéi och ëmmer, net jiddereen huet d'Zäit, d'Gedold oder d'Ressourcen fir Bitmap-Indexe vun Null ze kreéieren. Besonnesch méi fortgeschratt, mat SIMD, zum Beispill.
Glécklecherweis ginn et e puer fäerdeg Léisunge fir Iech ze hëllefen.
Roaring Bitmaps
Als éischt gëtt et déiselwecht roaring Bitmaps Bibliothéik iwwer déi ech scho geschwat hunn. Et enthält all déi néideg Container a Bitoperatiounen déi Dir braucht fir e vollwäertege Bitmap Index ze maachen.
Leider, am Moment, benotzt keng vun de Go Implementatiounen SIMD, dat heescht datt Go Implementatiounen manner performant sinn wéi C Implementatiounen, zum Beispill.
haart
En anert Produkt dat Iech hëllefe kann ass de Pilosa DBMS, deen tatsächlech nëmmen Bitmap Indexen huet. Dëst ass eng relativ nei Léisung, awer et gewënnt Häerzer mat grousser Geschwindegkeet.
Pilosa benotzt roaring Bitmaps intern a gëtt Iech d'Méiglechkeet se ze benotzen, vereinfacht an erkläert all d'Saachen, iwwer déi ech uewen geschwat hunn: Gruppéierung, Range-kodéiert Bitmaps, d'Konzept vun engem Feld, etc.
Loosst eis séier e Beispill kucken fir Pilosa ze benotzen fir eng Fro ze beäntweren déi Dir scho kennt.
D'Beispill ass ganz ähnlech wéi wat Dir virdru gesinn hutt. Mir kreéieren e Client op de Pilosa-Server, kreéieren en Index an déi néideg Felder, fëllen dann eis Felder mat zoufälleger Donnéeën mat Wahrscheinlechkeeten an, schlussendlech, ausféieren déi vertraute Ufro.
Duerno benotze mir NET op dem "deier" Feld, da schneide mir d'Resultat (oder AN et) mam Feld "Terrass" a mam Feld "Reservatiounen". A schlussendlech kréie mir d'Finale Resultat.
Ech hoffen wierklech datt an absehbarer Zukunft dës nei Zort Index och an DBMSs wéi MySQL a PostgreSQL - Bitmap Indexen erscheint.
Konklusioun
Wann Dir nach net ageschlof sidd, Merci. Ech hu misse kuerz op vill Themen ugoen wéinst limitéierter Zäit, awer ech hoffen, datt d'Diskussioun nëtzlech a vläicht souguer motivéiert war.
Bitmap Indexe si gutt iwwer ze wëssen, och wann Dir se elo net braucht. Loosst se en anert Tool an Ärer Toolbox sinn.
Mir hu verschidde Performance Tricks fir Go gekuckt a Saachen déi de Go Compiler nach net ganz gutt handhabt. Awer dëst ass absolut nëtzlech fir all Go Programméierer ze wëssen.
Dat war alles wat ech Iech wollt soen. Merci!
Source: will.com