Bro SQL-NoSQL-gapet med Apache Phoenix

Apache Phoenix er et relativt nytt open source Java-prosjekt som gir en JDBC-driver og SQL-tilgang til Hadoops NoSQL-database: HBase. Det ble opprettet som et internt prosjekt hos Salesforce, åpen fra GitHub, og ble et topp-nivå Apache-prosjekt i mai 2014. Hvis du har sterke SQL-programmeringsevner og vil kunne bruke dem med en kraftig NoSQL-database, Phoenix kan være akkurat det du leter etter!

Denne opplæringen introduserer Java-utviklere for Apache Phoenix. Siden Phoenix kjører på toppen av HBase, begynner vi med en oversikt over HBase og hvordan den skiller seg fra relasjonsdatabaser. Du lærer hvordan Phoenix bygger bro mellom SQL og NoSQL, og hvordan den er optimalisert for effektivt å samhandle med HBase. Når disse grunnleggende er ute av veien, vil vi bruke resten av artikkelen på å lære å jobbe med Phoenix. Du setter opp og integrerer HBase og Phoenix, oppretter et Java-program som kobles til HBase gjennom Phoenix, og du skriver din første tabell, setter inn data og kjører noen spørsmål på den.

Fire typer NoSQL-datalager

Det er interessant (og noe ironisk) at NoSQL-datalagre er kategorisert etter en funksjon som de mangler, nemlig SQL. NoSQL-datalagre kommer i fire generelle smaker:

Nøkkel- / verdibutikker kartlegge en bestemt nøkkel til en verdi, som kan være et dokument, en matrise eller en enkel type. Eksempler på nøkkel- / verdibutikker inkluderer Memcached, Redis og Riak.
Dokumentforretninger administrere dokumenter, som vanligvis er skjemafrie strukturer, som JSON, som kan være av vilkårlig kompleksitet. De fleste dokumentbutikker støtter både primære indekser og sekundære indekser og komplekse spørsmål. Eksempler på dokumentbutikker inkluderer MongoDB og CouchBase.
Grafdatabaser fokusere først og fremst på forholdet mellom objekter der data lagres i noder og i forholdet mellom noder. Et eksempel på en grafdatabase er Neo4j.
Kolonneorienterte databaser lagre data som seksjoner av datakolonner i stedet for som datarader. HBase er en kolonneorientert database, og det er også Cassandra.

HBase: En grunning

Apache HBase er en NoSQL-database som kjører på toppen av Hadoop som en distribuert og skalerbar stor datalager. HBase er en kolonneorientert database som utnytter de distribuerte prosesseringsegenskapene til Hadoop Distributed File System (HDFS) og Hadoop's MapReduce programmeringsparadigme. Den ble designet for å være vert for store bord med milliarder av rader og potensielt millioner av kolonner, som alle kjører over en klynge av råvaremaskinvare.

Apache HBase kombinerer kraften og skalerbarheten til Hadoop med muligheten til å spørre etter individuelle poster og utføre MapReduce-prosesser.

I tillegg til evner som er arvet fra Hadoop, er HBase en kraftig database i seg selv: den kombinerer sanntidsforespørsler med hastigheten til en nøkkel- / verdilager, en robust bordskanningsstrategi for rask lokalisering av poster, og den støtter batchbehandling ved hjelp av MapReduce. Som sådan kombinerer Apache HBase kraften og skalerbarheten til Hadoop med muligheten til å spørre etter individuelle poster og utføre MapReduce-prosesser.

HBases datamodell

HBase organiserer data forskjellig fra tradisjonelle relasjonsdatabaser, og støtter en firedimensjonal datamodell der hver "celle" er representert av fire koordinater:

Radnøkkel: Hver rad har en unik radnøkkel som er representert internt av en byte-matrise, men ikke har noen formell datatype.
Søylefamilie: Dataene i en rad er delt inn i kolonnefamilier; hver rad har samme sett med kolonnefamilier, men hver kolonnefamilie trenger ikke å opprettholde det samme settet med kolonnekvalifiseringer. Du kan tenke på kolonnefamilier som ligner på tabeller i en relasjonsdatabase.
Kolonnekvalifisering: Disse ligner på kolonner i en relasjonsdatabase.
Versjon: Hver kolonne kan ha et konfigurerbart antall versjoner. Hvis du ber om dataene i en kolonne uten å spesifisere en versjon, mottar du den siste versjonen, men du kan be om eldre versjoner ved å spesifisere et versjonsnummer.

Figur 1 viser hvordan disse firedimensjonale koordinatene er relatert.

Steven Haines

Modellen i figur 1 viser at en rad består av en radnøkkel og et vilkårlig antall kolonnefamilier. Hver radnøkkel er knyttet til en samling av "rader i tabeller", som hver har sine egne kolonner. Selv om hver tabell må eksistere, kan kolonnene i tabellene være forskjellige på tvers av rader. Hver kolonnefamilie har et sett med kolonner, og hver kolonne har et sett med versjoner som tilordnes de faktiske dataene i raden.

Hvis vi modellerte en person, kan radnøkkelen være personens personnummer (for å identifisere dem unikt), og vi kan ha kolonnefamilier som adresse, ansettelse, utdanning og så videre. Inne i adresse kolonnefamilien vi kan ha gate-, by-, delstats- og postnummerkolonner, og hver versjon kan tilsvare hvor personen bodde til enhver tid. Den siste versjonen viser kanskje byen "Los Angeles", mens den forrige versjonen viser "New York." Du kan se denne eksempelmodellen i figur 2.

Steven Haines

I sum er HBase en kolonneorientert database som representerer data i en firedimensjonal modell. Den er bygget på toppen av Hadoop Distributed File System (HDFS), som partisjonerer data over potensielt tusenvis av råvaremaskiner. Utviklere som bruker HBase, kan få tilgang til data direkte ved å få tilgang til en radnøkkel, ved å skanne over en rekke radnøkler eller ved å bruke batchbehandling via MapReduce.

Grunnleggende forskning

Du er kanskje ikke kjent med de berømte (til nerdene) Big Data White Papers. Disse vitnemålene ble publisert av Google Research mellom 2003 og 2006 og presenterte forskningen for tre søyler i Hadoop-økosystemet slik vi kjenner det:

Google File System (GFS): Hadoop Distributed File System (HDFS) er en åpen kildekodeimplementering av GFS og definerer hvordan data distribueres over en klynge av råvaremaskiner.
MapReduce: Et funksjonelt programmeringsparadigme for å analysere data som distribueres over en HDFS-klynge.
Bigtable: Et distribuert lagringssystem for å administrere strukturerte data som er designet for å skalere til veldig store størrelser - petabyte data over tusenvis av råvaremaskiner. HBase er en åpen kildekode-implementering av Bigtable.

Å bygge bro over NoSQL-gapet: Apache Phoenix

Apache Phoenix er et toppache Apache-prosjekt som gir et SQL-grensesnitt til HBase, som kartlegger HBase-modeller til en relasjonell databaseverden. Selvfølgelig gir HBase sin egen API og shell for å utføre funksjoner som skanning, hent, put, liste og så videre, men flere utviklere er kjent med SQL enn NoSQL. Målet med Phoenix er å tilby et ofte forstått grensesnitt for HBase.

Når det gjelder funksjoner, gjør Phoenix følgende:

Tilbyr en JDBC-driver for samhandling med HBase.
Støtter mye av ANSI SQL-standarden.
Støtter DDL-operasjoner som CREATE TABLE, DROP TABLE og ALTER TABLE.
Støtter DML-operasjoner som UPSERT og DELETE.
Kompilerer SQL-spørringer til innfødte HBase-skanninger og tilordner deretter svaret til JDBC ResultSets.
Støtter versjonerte skjemaer.

I tillegg til å støtte et stort sett med SQL-operasjoner, har Phoenix også veldig gode resultater. Den analyserer SQL-spørringer, deler dem opp i flere HBase-skanninger, og kjører dem parallelt ved hjelp av det opprinnelige API-stedet i stedet for MapReduce-prosesser.

Phoenix bruker to strategier - co-prosessorer og tilpassede filtre - for å bringe beregninger nærmere dataene:

Medprosessorer utføre operasjoner på serveren, noe som minimerer klient / server dataoverføring.
Egendefinerte filtre redusere mengden data som returneres i et spørresvar fra serveren, noe som ytterligere reduserer mengden overførte data. Egendefinerte filtre brukes på noen få måter:
1. Når du utfører et spørsmål, kan et tilpasset filter brukes til å identifisere bare de viktigste kolonnefamiliene som kreves for å tilfredsstille søket.
2. EN hopp over skannefilter bruker HBases SEEK_NEXT_USING_HINT for raskt å navigere fra en post til den neste, noe som øker poengspørringene.
3. Et tilpasset filter kan "salte dataene", noe som betyr at det legger til en hash-byte i begynnelsen av radnøkkelen, slik at den raskt kan finne poster.

I sum utnytter Phoenix direkte tilgang til HBase APIer, co-prosessorer og tilpassede filtre for å gi deg ytelse på millisekundnivå for små datasett og ytelsesnivå for humongous. Fremfor alt eksponerer Phoenix disse mulighetene for utviklere via et kjent JDBC- og SQL-grensesnitt.

Kom i gang med Phoenix

For å kunne bruke Phoenix, må du laste ned og installere både HBase og Phoenix. Du finner Phoenix-nedlastingssiden (og HBase-kompatibilitetsmerknader) her.

Last ned og oppsett

I skrivende stund er den siste versjonen av Phoenix 4.6.0, og nedlastingssiden leser at 4.x er kompatibel med HBase versjon 0.98.1+. For mitt eksempel lastet jeg ned den nyeste versjonen av Phoenix som er konfigurert til å fungere med HBase 1.1. Du finner den i mappen: phoenix-4.6.0-HBase-1.1 /.

Her er oppsettet:

Last ned og komprimer dette arkivet, og bruk deretter en av de anbefalte speilsidene her for å laste ned HBase. For eksempel valgte jeg et speil, navigerte inn i 1.1.2-mappen og lastet ned hbase-1.1.2-bin.tar.gz.
Komprimer denne filen og opprett en HBASE_HOME miljøvariabel som peker på den; for eksempel la jeg til følgende til min ~ / .bash_profile fil (på Mac): eksporter HBASE_HOME = / Brukere / shaines / Nedlastinger / hbase-1.1.2.

Integrer Phoenix med HBase

Prosessen med å integrere Phoenix i HBase er enkel:

Kopier følgende fil fra Phoenix rotkatalog til HBase lib katalog: phoenix-4.6.0-HBase-1.1-server.jar.
Start HBase ved å utføre følgende skript fra HBase søppel katalog:./start-hbase.sh.
Mens HBase kjører, test at Phoenix jobber ved å kjøre SQLLine-konsollen, ved å utføre følgende kommando fra Phoenix søppel katalog: ./sqlline.py lokal vert.

SQLLine-konsollen

sqlline.py er et Python-skript som starter en konsoll som kobles til HBases Zookeeper-adresse; lokal vert i dette tilfellet. Du kan gå gjennom et eksempel som jeg skal oppsummere i denne delen her.

La oss først se på alle tabellene i HBase ved å utføre !bord:

 0: jdbc: phoenix: localhost>! Tabeller + --------------------------------------- --- + ------------------------------------------ + --- --------------------------------------- + ---------- -------------------------------- + ----------------- --------- + | TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | MERKNADER | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- + | | SYSTEM | KATALOG | SYSTEMTABELL | | | | SYSTEM | FUNKSJON | SYSTEMTABELL | | | | SYSTEM | SEKVENS | SYSTEMTABELL | | | | SYSTEM | STATISTIK | SYSTEMTABELL | | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- +

Fordi dette er en ny forekomst av HBase, er de eneste tabellene som finnes systemtabeller. Du kan opprette en tabell ved å utføre en lage bord kommando:

 0: jdbc: phoenix: localhost>opprett tabelltest (mykey heltall ikke null primærnøkkel, mycolumn varchar); Ingen rader påvirket (2.448 sekunder)

Denne kommandoen oppretter en tabell med navnet test, med et heltall primærnøkkel nøkkelen min og en varchar kolonne oppkalt mycolumn. Sett inn et par rader ved å bruke upsert kommando:

 0: jdbc: phoenix: localhost>oppsving i testverdier (1, 'Hello'); 1 rad berørt (0,142 sekunder) 0: jdbc: phoenix: localhost>oppsving i testverdier (2, 'Verden!'); 1 rad berørt (0,008 sekunder)

UPSERT er en SQL-kommando for å sette inn en post hvis den ikke finnes eller oppdatere en post hvis den gjør det. I dette tilfellet la vi inn (1, 'Hei') og (2, 'Verden!'). Du finner den komplette Phoenix-kommandoreferansen her. Til slutt, spør bordet ditt for å se verdiene du opprørte ved å utføre velg * fra test:

 0: jdbc: phoenix: localhost>velg * fra test; + ------------------------------------------ + ------ ------------------------------------ + | MYKEY | MYCOLUMN | + ------------------------------------------ + ------ ------------------------------------ + | 1 | Hei | | 2 | Verden! | + ------------------------------------------ + ------ ------------------------------------ + 2 rader valgt (0,111 sekunder)

Som forventet ser du verdiene du nettopp har satt inn. Hvis du vil rydde opp i bordet, må du utføre a drop table test kommando.