Apache Phoenix je relativně nový open source projekt Java, který poskytuje ovladač JDBC a přístup SQL k databázi NoSQL společnosti Hadoop: HBase. Byl vytvořen jako interní projekt ve Salesforce, otevřen na GitHubu a v květnu 2014 se stal projektem Apache nejvyšší úrovně. Pokud máte silné znalosti programování v SQL a chtěli byste je používat s výkonnou databází NoSQL, Phoenix může být přesně to, co hledáte!
Tento kurz seznamuje vývojáře jazyka Java s Apache Phoenix. Protože Phoenix běží na vrcholu HBase, začneme s přehledem HBase a tím, jak se liší od relačních databází. Dozvíte se, jak Phoenix překlenuje propast mezi SQL a NoSQL a jak je optimalizován pro efektivní interakci s HBase. S těmito základy z cesty, strávíme zbytek článku tím, že se naučíme pracovat s Phoenixem. Nastavíte a integrujete HBase a Phoenix, vytvoříte aplikaci Java, která se připojí k HBase prostřednictvím Phoenixu, a napíšete svou první tabulku, vložíte data a spustíte několik dotazů.
Čtyři typy úložiště dat NoSQL
Je zajímavé (a poněkud ironické), že úložiště dat NoSQL jsou kategorizována podle funkce, která jim chybí, a to SQL. Úložiště dat NoSQL mají čtyři hlavní příchutě:
- Úložiště klíč / hodnota namapujte konkrétní klíč na hodnotu, což může být dokument, pole nebo jednoduchý typ. Mezi příklady obchodů klíč / hodnota patří Memcached, Redis a Riak.
- Obchody s dokumenty spravovat dokumenty, které jsou obvykle strukturami bez schémat, jako je JSON, které mohou mít libovolnou složitost. Většina obchodů s dokumenty poskytuje podporu pro primární indexy i sekundární indexy a složité dotazy. Mezi příklady úložišť dokumentů patří MongoDB a CouchBase.
- Grafové databáze zaměřit se primárně na vztahy mezi objekty, ve kterých jsou data uložena v uzlech, a na vztahy mezi uzly. Příkladem databáze grafů je Neo4j.
- Sloupcově orientované databáze ukládat data jako části sloupců dat, nikoli jako řádky dat. HBase je sloupově orientovaná databáze, stejně jako Cassandra.
HBase: Základní nátěr
Apache HBase je databáze NoSQL, která běží na Hadoopu jako distribuované a škálovatelné úložiště velkých dat. HBase je sloupově orientovaná databáze, která využívá možnosti distribuovaného zpracování systému Hadoop Distributed File System (HDFS) a programovacího paradigmatu Mapadoed společnosti Hadoop. Byl navržen tak, aby hostil velké tabulky s miliardami řádků a potenciálně miliony sloupců, všechny běžící v klastru komoditního hardwaru.
Apache HBase kombinuje sílu a škálovatelnost Hadoop se schopností dotazovat se na jednotlivé záznamy a spouštět procesy MapReduce.
Kromě funkcí zděděných od Hadoop je HBase samostatnou výkonnou databází: kombinuje dotazy v reálném čase s rychlostí úložiště klíčů / hodnot, robustní strategii skenování tabulek pro rychlé vyhledání záznamů a podporuje dávkové zpracování pomocí MapReduce. Apache HBase jako takový kombinuje výkon a škálovatelnost Hadoop se schopností dotazovat se na jednotlivé záznamy a spouštět procesy MapReduce.
Datový model HBase
HBase organizuje data odlišně od tradičních relačních databází a podporuje čtyřrozměrný datový model, ve kterém je každá „buňka“ reprezentována čtyřmi souřadnicemi:
- Klíč řádku: Každý řádek má svůj vlastní klíč řádku který je interně reprezentován bajtovým polem, ale nemá žádný formální datový typ.
- Rodina sloupců: Data obsažená v řádku jsou rozdělena na rodiny sloupců; každý řádek má stejnou sadu rodin sloupců, ale každá rodina sloupců nemusí udržovat stejnou sadu kvalifikátorů sloupců. Skupiny sloupců si můžete představit jako podobné tabulkám v relační databázi.
- Kvalifikátor sloupce: Jsou podobné sloupcům v relační databázi.
- Verze: Každý sloupec může mít nastavitelný počet verze. Pokud požadujete data obsažená ve sloupci bez zadání verze, obdržíte nejnovější verzi, ale můžete požádat o starší verze zadáním čísla verze.
Obrázek 1 ukazuje, jak tyto čtyřrozměrné souřadnice souvisejí.
Steven Haines Model na obrázku 1 ukazuje, že řádek se skládá z klíče řádku a libovolného počtu rodin sloupců. Každý klíč řádku je přidružen ke kolekci „řádků v tabulkách“, z nichž každý má své vlastní sloupce. I když každá tabulka musí existovat, sloupce v tabulkách se mohou v různých řádcích lišit. Každá rodina sloupců má sadu sloupců a každý sloupec má sadu verzí, které se mapují na skutečná data v řádku.
Pokud bychom modelovali osobu, klíčem řádku by mohlo být číslo sociálního zabezpečení osoby (abychom je jednoznačně identifikovali) a mohli bychom mít rodiny sloupců, jako je adresa, zaměstnání, vzdělání atd. Uvnitř adresa rodinu sloupců můžeme mít sloupce ulice, města, státu a PSČ a každá verze může odpovídat tomu, kde daná osoba kdykoli žila. Nejnovější verze může uvádět město „Los Angeles“, zatímco předchozí verze může obsahovat „New York“. Tento příkladový model můžete vidět na obrázku 2.
Steven Haines Stručně řečeno, HBase je sloupově orientovaná databáze, která představuje data ve čtyřrozměrném modelu. Je postaven na Hadoop Distributed File System (HDFS), který rozděluje data napříč potenciálně tisíci komoditních strojů. Vývojáři používající HBase mohou přistupovat k datům přímo přístupem ke klíči řádku, skenováním přes celou řadu klíčů řádků nebo pomocí dávkového zpracování prostřednictvím MapReduce.
Základní výzkum
Možná znáte nebo nemusíte znát slavné (pro geeky) Big Data White Papers. Tyto dokumenty publikované společností Google Research v letech 2003 až 2006 představily výzkum tří pilířů ekosystému Hadoop, jak jej známe:
- Google File System (GFS): The Hadoop Distributed File System (HDFS) is an open source implementation of the GFS and defines how data is distributed across a cluster of commodity machines.
- MapReduce: paradigma funkčního programování pro analýzu dat distribuovaných v clusteru HDFS.
- Bigtable: Distribuovaný úložný systém pro správu strukturovaných dat, který je určen k škálování na velmi velké velikosti - petabajty dat napříč tisíci komoditních strojů. HBase je open source implementace Bigtable.
Překlenutí propasti NoSQL: Apache Phoenix
Apache Phoenix je projekt nejvyšší úrovně Apache, který poskytuje rozhraní SQL pro HBase a mapuje modely HBase na svět relačních databází. HBase samozřejmě poskytuje své vlastní API a prostředí pro provádění funkcí, jako je skenování, získávání, vkládání, seznam atd., Ale více vývojářů zná SQL než NoSQL. Cílem Phoenixu je poskytnout běžně chápané rozhraní pro HBase.
Pokud jde o funkce, Phoenix dělá následující:
- Poskytuje ovladač JDBC pro interakci s HBase.
- Podporuje velkou část standardu ANSI SQL.
- Podporuje operace DDL, například CREATE TABLE, DROP TABLE a ALTER TABLE.
- Podporuje operace DML, jako jsou UPSERT a DELETE.
- Zkompiluje dotazy SQL do nativních skenování HBase a poté mapuje odpověď na sady výsledků JDBC.
- Podporuje verzovaná schémata.
Kromě podpory rozsáhlé sady operací SQL má Phoenix také velmi vysoký výkon. Analyzuje dotazy SQL, rozdělí je na několik skenování HBase a spustí je paralelně pomocí nativního API namísto procesů MapReduce.
Phoenix používá dvě strategie - koprocesory a vlastní filtry - k přiblížení výpočtů k datům:
- Společní zpracovatelé provádět operace na serveru, což minimalizuje přenos dat klient / server.
- Vlastní filtry snížit množství dat vrácených v odpovědi serveru na dotaz, což dále sníží množství přenesených dat. Vlastní filtry se používají několika způsoby:
- Při provádění dotazu lze použít vlastní filtr k identifikaci pouze základních rodin sloupců požadovaných k uspokojení hledání.
- A přeskočit filtr skenování používá SEEK_NEXT_USING_HINT společnosti HBase k rychlé navigaci z jednoho záznamu do druhého, což zrychluje dotazy na body.
- Vlastní filtr může „zasolit data“, což znamená, že na začátek řádku přidá hašovací bajt, aby mohl rychle vyhledat záznamy.
Stručně řečeno, Phoenix využívá přímý přístup k HBase API, koprocesorům a vlastním filtrům, aby vám poskytl výkon na milisekundu pro malé datové sady a výkon na druhé úrovni pro humongous. Phoenix především vystavuje tyto funkce vývojářům prostřednictvím známého rozhraní JDBC a SQL.
Začněte s Phoenixem
Abyste mohli používat Phoenix, musíte si stáhnout a nainstalovat HBase i Phoenix. Stránku Phoenix ke stažení (a poznámky ke kompatibilitě HBase) najdete zde.
Stažení a nastavení
V době psaní tohoto článku je nejnovější verze Phoenixu 4.6.0 a na stránce pro stahování se píše, že 4.x je kompatibilní s HBase verze 0.98.1+. Pro můj příklad jsem stáhl nejnovější verzi Phoenixu, který je nakonfigurován pro práci s HBase 1.1. Najdete jej ve složce: Phoenix-4.6.0-HBase-1.1 /.
Zde je nastavení:
- Stáhněte a dekomprimujte tento archiv a poté použijte jednu z doporučených zrcadlových stránek ke stažení HBase. Například jsem vybral zrcadlo, navigoval do složky 1.1.2 a stáhl
hbase-1.1.2-bin.tar.gz. - Dekomprimujte tento soubor a vytvořte soubor
HBASE_HOMEproměnná prostředí, která na ni odkazuje; například jsem do mého přidal následující~ / .bash_profilesoubor (pro Mac):export HBASE_HOME = / Uživatelé / shaines / Stahování / hbase-1.1.2.
Integrujte Phoenix s HBase
Proces integrace Phoenixu do HBase je jednoduchý:
- Zkopírujte následující soubor z kořenového adresáře Phoenix do HBase
libadresář:phoenix-4.6.0-HBase-1.1-server.jar. - Spusťte HBase spuštěním následujícího skriptu z HBase
zásobníkadresář:./start-hbase.sh. - Při spuštěném HBase otestujte, že Phoenix pracuje, spuštěním konzoly SQLLine provedením následujícího příkazu od Phoenixu
zásobníkadresář:./sqlline.py localhost.
Konzola SQLLine
sqlline.py je skript v Pythonu, který spouští konzolu, která se připojuje k adrese Zoaseeper HBase; localhost v tomto případě. Zde můžete projít příkladem, který zde shrnu.
Nejprve se podívejme na provedení všech tabulek v HBase !stůl:
0: jdbc: phoenix: localhost>! Tables + --------------------------------------- --- + ------------------------------------------ + --- --------------------------------------- + ---------- -------------------------------- + ----------------- --------- + | TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | POZNÁMKY | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- + | | SYSTÉM | KATALOG | TABULKA SYSTÉMU | | | | SYSTÉM | FUNKCE | TABULKA SYSTÉMU | | | | SYSTÉM | SEKVENCE | TABULKA SYSTÉMU | | | | SYSTÉM | STÁTY | TABULKA SYSTÉMU | | + ------------------------------------------ + ------ ------------------------------------ + ------------- ----------------------------- + -------------------- ---------------------- + -------------------------- + Protože se jedná o novou instanci HBase, jediné tabulky, které existují, jsou systémové tabulky. Tabulku můžete vytvořit spuštěním a vytvořit tabulku příkaz:
0: jdbc: phoenix: localhost>vytvořit test tabulky (celé číslo mykey ne null primární klíč, mycolumn varchar); Žádné ovlivněné řádky (2,448 sekundy) Tento příkaz vytvoří tabulku s názvem test, s názvem celočíselného primárního klíče můj klíč a varchar pojmenovaný sloupec mycolumn. Nyní vložte několik řádků pomocí upsert příkaz:
0: jdbc: phoenix: localhost>upsert do testovacích hodnot (1, 'Hello'); 1 řádek ovlivněn (0,142 sekundy) 0: jdbc: phoenix: localhost>upsert do testovacích hodnot (2, 'World!'); 1 ovlivněný řádek (0,008 sekundy) UPSERT je příkaz SQL pro vložení záznamu, pokud neexistuje, nebo aktualizaci záznamu, pokud existuje. V tomto případě jsme vložili (1, „Hello“) a (2, „World!“). Kompletní odkaz na příkaz Phoenix najdete zde. Nakonec dotazujte svoji tabulku, abyste viděli hodnoty, které jste upserted provedením vyberte * z testu:
0: jdbc: phoenix: localhost>vyberte * z testu; + ------------------------------------------ + ------ ------------------------------------ + | MYKEY | MYCOLUMN | + ------------------------------------------ + ------ ------------------------------------ + | 1 | Ahoj | | 2 | Svět! | + ------------------------------------------ + ------ ------------------------------------ + 2 vybrané řádky (0,111 sekundy) Podle očekávání uvidíte hodnoty, které jste právě vložili. Chcete-li vyčistit stůl, proveďte a test pádové tabulky příkaz.
