Brug SQL-NoSQL-kløften med Apache Phoenix

Apache Phoenix er et relativt nyt open source Java-projekt, der giver en JDBC-driver og SQL-adgang til Hadoop's NoSQL-database: HBase. Det blev oprettet som et internt projekt hos Salesforce, åbent indkøbt på GitHub og blev et Apache-projekt på højeste niveau i maj 2014. Hvis du har stærke SQL-programmeringsevner og gerne vil kunne bruge dem med en stærk NoSQL-database, Phoenix kunne være præcis, hvad du leder efter!

Denne vejledning introducerer Java-udviklere til Apache Phoenix. Da Phoenix kører oven på HBase, starter vi med et overblik over HBase, og hvordan det adskiller sig fra relationsdatabaser. Du lærer, hvordan Phoenix bygger bro mellem SQL og NoSQL, og hvordan det er optimeret til effektivt at interagere med HBase. Med disse grundlæggende ting ude af vejen bruger vi resten af artiklen til at lære at arbejde med Phoenix. Du opretter og integrerer HBase og Phoenix, opretter en Java-applikation, der opretter forbindelse til HBase gennem Phoenix, og du skriver din første tabel, indsætter data og kører et par forespørgsler på den.

Fire typer NoSQL-datalager

Det er interessant (og noget ironisk), at NoSQL-datalagre er kategoriseret efter en funktion, som de mangler, nemlig SQL. NoSQL-datalagre findes i fire generelle varianter:

Nøgle- / værdibutikker kortlæg en bestemt nøgle til en værdi, som kan være et dokument, en matrix eller en simpel type. Eksempler på nøgle- / værdibutikker inkluderer Memcached, Redis og Riak.
Dokumentforretninger administrere dokumenter, som normalt er skemafri strukturer, som JSON, der kan være af vilkårlig kompleksitet. De fleste dokumentbutikker understøtter primære indekser samt sekundære indekser og komplekse forespørgsler. Eksempler på dokumentforretninger inkluderer MongoDB og CouchBase.
Grafdatabaser fokuserer primært på forholdet mellem objekter, hvor data er gemt i noder og i forholdet mellem noder. Et eksempel på en grafdatabase er Neo4j.
Kolonneorienterede databaser gem data som sektioner af datakolonner snarere end som datarækker. HBase er en kolonneorienteret database, og det er Cassandra også.

HBase: En primer

Apache HBase er en NoSQL-database, der kører oven på Hadoop som et distribueret og skalerbart big datalager. HBase er en kolonneorienteret database, der udnytter de distribuerede behandlingsfunktioner i Hadoop Distributed File System (HDFS) og Hadoop's MapReduce programmeringsparadigme. Det blev designet til at være vært for store tabeller med milliarder af rækker og potentielt millioner af kolonner, der alle kører på tværs af en klynge af råvarehardware.

Apache HBase kombinerer kraften og skalerbarheden af Hadoop med evnen til at spørge efter individuelle poster og udføre MapReduce-processer.

Ud over de egenskaber, der er nedarvet fra Hadoop, er HBase en stærk database i sig selv: Den kombinerer realtidsforespørgsler med hastigheden i et nøgle- / værdilager, en robust bordscanningsstrategi til hurtig lokalisering af poster og understøtter batchbehandling ved hjælp af MapReduce. Som sådan kombinerer Apache HBase kraften og skalerbarheden af Hadoop med evnen til at søge efter individuelle poster og udføre MapReduce-processer.

HBases datamodel

HBase organiserer data forskelligt fra traditionelle relationsdatabaser og understøtter en firedimensionel datamodel, hvor hver "celle" er repræsenteret af fire koordinater:

Rækketast: Hver række har en unik række tast der er repræsenteret internt af et byte-array, men ikke har nogen formel datatype.
Kolonne familie: Dataene i en række er opdelt i kolonnefamilier; hver række har det samme sæt kolonnefamilier, men hver kolonnefamilie behøver ikke at opretholde det samme sæt kolonnekvalifikatorer. Du kan tænke på kolonnefamilier, der ligner tabeller i en relationsdatabase.
Søjlekvalifikation: Disse svarer til kolonner i en relationsdatabase.
Version: Hver kolonne kan have et konfigurerbart antal versioner. Hvis du anmoder om dataene i en kolonne uden at angive en version, modtager du den nyeste version, men du kan anmode om ældre versioner ved at angive et versionsnummer.

Figur 1 viser, hvordan disse fire dimensionelle koordinater er relateret.

Steven Haines

Modellen i figur 1 viser, at en række består af en rækkenøgle og et vilkårligt antal kolonnefamilier. Hver række nøgle er knyttet til en samling af "rækker i tabeller", som hver har sine egne kolonner. Mens hver tabel skal eksistere, kan kolonnerne i tabellerne være forskellige på tværs af rækker. Hver kolonnefamilie har et sæt kolonner, og hver kolonne har et sæt versioner, der kortlægges til de faktiske data i rækken.

Hvis vi modellerede en person, kunne række-nøglen muligvis være personens personnummer (for entydigt at identificere dem), og vi kunne have kolonnefamilier som adresse, beskæftigelse, uddannelse og så videre. Inde i adresse kolonnefamilie har vi muligvis gade-, by-, stat- og postnummerkolonner, og hver version svarer muligvis til, hvor personen boede til enhver tid. Den seneste version viser muligvis byen "Los Angeles", mens den tidligere version muligvis viser "New York." Du kan se denne eksempelmodel i figur 2.

Steven Haines

I sum er HBase en kolonneorienteret database, der repræsenterer data i en firedimensionel model. Det er bygget oven på Hadoop Distributed File System (HDFS), som partitionerer data på tværs af potentielt tusindvis af råmaskiner. Udviklere, der bruger HBase, kan få adgang til data direkte ved at få adgang til en række nøgle, ved at scanne på tværs af en række række nøgler eller ved at bruge batchbehandling via MapReduce.

Grundlæggende forskning

Du er måske eller måske ikke fortrolig med de berømte (til nørder) Big Data White Papers. Udgivet af Google Research mellem 2003 og 2006 præsenterede disse hvidbøger forskningen i tre søjler i Hadoop-økosystemet, som vi kender det:

Google File System (GFS): Hadoop Distributed File System (HDFS) er en open source-implementering af GFS og definerer, hvordan data distribueres over en klynge af råvaremaskiner.
MapReduce: Et funktionelt programmeringsparadigme til analyse af data, der distribueres over en HDFS-klynge.
Bigtable: Et distribueret lagersystem til styring af strukturerede data, der er designet til at skalere til meget store størrelser - petabytes af data på tværs af tusinder af råvaremaskiner. HBase er en open source-implementering af Bigtable.

Overbygning af NoSQL-hullet: Apache Phoenix

Apache Phoenix er et top-niveau Apache-projekt, der giver en SQL-grænseflade til HBase, der kortlægger HBase-modeller til en relationel databaseverden. Naturligvis leverer HBase sin egen API og shell til at udføre funktioner som scanning, get, put, liste osv., Men flere udviklere er fortrolige med SQL end NoSQL. Målet med Phoenix er at tilvejebringe en almindeligt forstået grænseflade til HBase.

Med hensyn til funktioner gør Phoenix følgende:

Tilbyder en JDBC-driver til interaktion med HBase.
Understøtter meget af ANSI SQL-standarden.
Understøtter DDL-operationer som CREATE TABLE, DROP TABLE og ALTER TABLE.
Understøtter DML-operationer som UPSERT og DELETE.
Kompilerer SQL-forespørgsler til indfødte HBase-scanninger og kortlægger derefter svaret til JDBC ResultSets.
Understøtter skemaer med versioner.

Ud over at understøtte et stort sæt SQL-operationer er Phoenix også meget effektiv. Det analyserer SQL-forespørgsler, opdeler dem i flere HBase-scanninger og kører dem parallelt ved hjælp af den oprindelige API i stedet for MapReduce-processer.

Phoenix bruger to strategier - co-processorer og brugerdefinerede filtre - for at bringe beregninger tættere på dataene:

Co-processorer udføre operationer på serveren, hvilket minimerer overførsel af klient / serverdata.
Brugerdefinerede filtre reducere mængden af data, der returneres i et forespørgselssvar fra serveren, hvilket yderligere reducerer mængden af overførte data. Brugerdefinerede filtre bruges på få måder:
1. Når du udfører en forespørgsel, kan et brugerdefineret filter bruges til kun at identificere de væsentlige kolonnefamilier, der kræves for at tilfredsstille søgningen.
2. EN spring scanfilter over bruger HBases SEEK_NEXT_USING_HINT til hurtigt at navigere fra en post til den næste, hvilket fremskynder punktforespørgsler.
3. Et brugerdefineret filter kan "salte dataene", hvilket betyder, at det tilføjer en hash-byte i begyndelsen af række-nøglen, så det hurtigt kan finde poster.

Alt i alt udnytter Phoenix direkte adgang til HBase API'er, co-processorer og brugerdefinerede filtre for at give dig ydeevne på millisekundniveau for små datasæt og andet niveau ydeevne for humongous. Frem for alt udsætter Phoenix disse muligheder for udviklere via en velkendt JDBC- og SQL-grænseflade.

Kom godt i gang med Phoenix

For at kunne bruge Phoenix skal du downloade og installere både HBase og Phoenix. Du kan finde Phoenix download-siden (og HBase kompatibilitetsnoter) her.

Download og opsætning

På dette tidspunkt er den seneste version af Phoenix 4.6.0, og download-siden læser, at 4.x er kompatibel med HBase version 0.98.1+. For mit eksempel downloadede jeg den nyeste version af Phoenix, der er konfigureret til at arbejde med HBase 1.1. Du kan finde det i mappen: phoenix-4.6.0-HBase-1.1 /.

Her er opsætningen:

Download og dekomprimér dette arkiv, og brug derefter en af de anbefalede spejlsider her for at downloade HBase. For eksempel valgte jeg et spejl, navigerede ind i 1.1.2-mappen og downloadede hbase-1.1.2-bin.tar.gz.
Komprimer denne fil, og opret en HBASE_HOME miljøvariabel, der peger på det; for eksempel tilføjede jeg følgende til min ~ / .bash_profile fil (på Mac): eksport HBASE_HOME = / Brugere / shaines / Downloads / hbase-1.1.2.

Integrer Phoenix med HBase

Processen til at integrere Phoenix i HBase er enkel:

Kopier følgende fil fra Phoenix rodmappe til HBase lib vejviser: phoenix-4.6.0-HBase-1.1-server.jar.
Start HBase ved at udføre følgende script fra HBase's beholder vejviser:./start-hbase.sh.
Mens HBase kører, test at Phoenix arbejder ved at udføre SQLLine-konsollen ved at udføre følgende kommando fra Phoenix beholder vejviser: ./sqlline.py localhost.

SQLLine-konsollen

sqlline.py er et Python-script, der starter en konsol, der opretter forbindelse til HBases Zookeeper-adresse; lokal vært I dette tilfælde. Du kan gennemgå et eksempel, som jeg vil opsummere i dette afsnit her.

Lad os først se alle tabellerne i HBase ved at udføre !bord:

 0: jdbc: phoenix: localhost>! Tabeller + --------------------------------------- --- + ------------------------------------------ + --- --------------------------------------- + ---------- -------------------------------- + ----------------- --------- + | TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | BEMÆRKNINGER | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- + | | SYSTEM | KATALOG | SYSTEMTABEL | | | | SYSTEM | FUNKTION | SYSTEMTABEL | | | | SYSTEM | SEKVENS | SYSTEMTABEL | | | | SYSTEM | STATISTIK | SYSTEMTABEL | | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- +

Da dette er en ny forekomst af HBase, er de eneste tabeller, der findes, systemtabeller. Du kan oprette en tabel ved at udføre en Opret tabel kommando:

 0: jdbc: phoenix: localhost>Opret tabel test (mykey heltal ikke nul primær nøgle, mycolumn varchar); Ingen rækker berørt (2.448 sekunder)

Denne kommando opretter en tabel med navnet prøve, med et heltal primærnøgle navngivet mykey og en varchar kolonne navngivet mycolumn. Indsæt nu et par rækker ved hjælp af opsving kommando:

 0: jdbc: phoenix: localhost>opsving i testværdier (1, 'Hej'); 1 række berørt (0,142 sekunder) 0: jdbc: phoenix: localhost>opsving i testværdier (2, 'Verden!'); 1 række berørt (0,008 sekunder)

UPSERT er en SQL-kommando til at indsætte en post, hvis den ikke findes, eller opdatere en post, hvis den findes. I dette tilfælde indsatte vi (1, 'Hej') og (2, 'Verden!'). Du kan finde den komplette Phoenix-kommandoreference her. Endelig forespørg din tabel for at se de værdier, du oprørte ved at udføre vælg * fra test:

 0: jdbc: phoenix: localhost>vælg * fra test; + ------------------------------------------ + ------ ------------------------------------ + | MYKEY | MYCOLUMN | + ------------------------------------------ + ------ ------------------------------------ + | 1 | Hej | | 2 | Verden! | + ------------------------------------------ + ------ ------------------------------------ + 2 rækker valgt (0.111 sekunder)

Som forventet ser du de værdier, du lige har indsat. Hvis du vil rydde op i bordet, skal du udføre a drop tabeltest kommando.