Überbrücken Sie die SQL-NoSQL-Lücke mit Apache Phoenix

Apache Phoenix ist ein relativ neues Open-Source-Java-Projekt, das einen JDBC-Treiber und SQL-Zugriff auf die NoSQL-Datenbank von Hadoop bietet: HBase. Es wurde als internes Projekt bei Salesforce erstellt, Open Source auf GitHub und wurde im Mai 2014 zu einem Apache-Projekt der obersten Ebene. Wenn Sie über gute SQL-Programmierkenntnisse verfügen und diese mit einer leistungsstarken NoSQL-Datenbank verwenden möchten, Phoenix könnte genau das sein, wonach Sie suchen!

Dieses Tutorial führt Java-Entwickler in Apache Phoenix ein. Da Phoenix auf HBase läuft, beginnen wir mit einem Überblick über HBase und wie es sich von relationalen Datenbanken unterscheidet. Sie erfahren, wie Phoenix die Lücke zwischen SQL und NoSQL schließt und wie es für eine effiziente Interaktion mit HBase optimiert ist. Mit diesen Grundlagen werden wir den Rest des Artikels damit verbringen, zu lernen, wie man mit Phoenix arbeitet. Sie richten HBase und Phoenix ein und integrieren sie, erstellen eine Java-Anwendung, die über Phoenix eine Verbindung zu HBase herstellt, schreiben Ihre erste Tabelle, fügen Daten ein und führen einige Abfragen darauf aus.

Vier Arten von NoSQL-Datenspeichern

Es ist interessant (und etwas ironisch), dass NoSQL-Datenspeicher nach einer Funktion kategorisiert werden, die ihnen fehlt, nämlich SQL. NoSQL-Datenspeicher gibt es in vier allgemeinen Varianten:

  1. Schlüssel- / Wertspeicher ordnen einen bestimmten Schlüssel einem Wert zu, der ein Dokument, ein Array oder ein einfacher Typ sein kann. Beispiele für Schlüssel- / Wertspeicher sind Memcached, Redis und Riak.
  2. Dokumentenspeicher verwalten Dokumente, bei denen es sich normalerweise um schemalose Strukturen wie JSON handelt, die von beliebiger Komplexität sein können. Die meisten Dokumentenspeicher bieten Unterstützung für Primärindizes sowie Sekundärindizes und komplexe Abfragen. Beispiele für Dokumentenspeicher sind MongoDB und CouchBase.
  3. Diagrammdatenbanken konzentrieren sich hauptsächlich auf die Beziehungen zwischen Objekten, in denen Daten in Knoten gespeichert sind, und auf die Beziehungen zwischen Knoten. Ein Beispiel für eine Grafikdatenbank ist Neo4j.
  4. Spaltenorientierte Datenbanken speichern Daten als Abschnitte von Datenspalten und nicht als Datenzeilen. HBase ist eine spaltenorientierte Datenbank, ebenso wie Cassandra.

HBase: Ein Primer

Apache HBase ist eine NoSQL-Datenbank, die auf Hadoop als verteilter und skalierbarer Big Data Store ausgeführt wird. HBase ist eine spaltenorientierte Datenbank, die die verteilten Verarbeitungsfunktionen des Hadoop Distributed File System (HDFS) und des MapReduce-Programmierparadigmas von Hadoop nutzt. Es wurde entwickelt, um große Tabellen mit Milliarden von Zeilen und möglicherweise Millionen von Spalten zu hosten, die alle auf einem Cluster von Standardhardware ausgeführt werden.

Apache HBase kombiniert die Leistung und Skalierbarkeit von Hadoop mit der Möglichkeit, einzelne Datensätze abzufragen und MapReduce-Prozesse auszuführen.

Zusätzlich zu den von Hadoop geerbten Funktionen ist HBase eine leistungsstarke Datenbank für sich: Sie kombiniert Echtzeitabfragen mit der Geschwindigkeit eines Schlüssel- / Wertspeichers, einer robusten Strategie zum Scannen von Tabellen zum schnellen Auffinden von Datensätzen und unterstützt die Stapelverarbeitung mit MapReduce. Daher kombiniert Apache HBase die Leistung und Skalierbarkeit von Hadoop mit der Möglichkeit, einzelne Datensätze abzufragen und MapReduce-Prozesse auszuführen.

Datenmodell von HBase

HBase organisiert Daten anders als herkömmliche relationale Datenbanken und unterstützt ein vierdimensionales Datenmodell, in dem jede "Zelle" durch vier Koordinaten dargestellt wird:

  1. Zeilenschlüssel : Jede Zeile verfügt über einen eindeutigen Zeilenschlüssel , der intern durch ein Byte-Array dargestellt wird, jedoch keinen formalen Datentyp hat.
  2. Spaltenfamilie : Die in einer Zeile enthaltenen Daten werden in Spaltenfamilien unterteilt . Jede Zeile hat denselben Satz von Spaltenfamilien, aber jede Spaltenfamilie muss nicht denselben Satz von Spaltenqualifizierern verwalten. Sie können sich Spaltenfamilien ähnlich wie Tabellen in einer relationalen Datenbank vorstellen.
  3. Spaltenqualifizierer : Diese ähneln Spalten in einer relationalen Datenbank.
  4. Version : Jede Spalte kann eine konfigurierbare Anzahl von Versionen haben . Wenn Sie die in einer Spalte enthaltenen Daten anfordern, ohne eine Version anzugeben, erhalten Sie die neueste Version. Sie können jedoch ältere Versionen anfordern, indem Sie eine Versionsnummer angeben.

Abbildung 1 zeigt, wie diese vierdimensionalen Koordinaten zusammenhängen.

Steven Haines

Das Modell in Abbildung 1 zeigt, dass eine Zeile aus einem Zeilenschlüssel und einer beliebigen Anzahl von Spaltenfamilien besteht. Jeder Zeilenschlüssel ist einer Sammlung von "Zeilen in Tabellen" zugeordnet, von denen jede ihre eigenen Spalten hat. Während jede Tabelle vorhanden sein muss, können die Spalten in Tabellen in den Zeilen unterschiedlich sein. Jede Spaltenfamilie verfügt über eine Reihe von Spalten, und jede Spalte verfügt über eine Reihe von Versionen, die den tatsächlichen Daten in der Zeile zugeordnet sind.

Wenn wir eine Person modellieren, könnte der Zeilenschlüssel die Sozialversicherungsnummer der Person sein (um sie eindeutig zu identifizieren), und wir könnten Spaltenfamilien wie Adresse, Beschäftigung, Bildung usw. haben. Innerhalb der Adressspaltenfamilie befinden sich möglicherweise Spalten für Straße, Stadt, Bundesland und Postleitzahl. Jede Version entspricht möglicherweise dem Wohnort der Person zu einem bestimmten Zeitpunkt. In der neuesten Version ist möglicherweise die Stadt "Los Angeles" aufgeführt, in der vorherigen Version möglicherweise "New York". Sie können dieses Beispielmodell in Abbildung 2 sehen.

Steven Haines

Insgesamt ist HBase eine spaltenorientierte Datenbank, die Daten in einem vierdimensionalen Modell darstellt. Es basiert auf dem Hadoop Distributed File System (HDFS), das Daten auf potenziell Tausenden von Standardmaschinen verteilt. Entwickler, die HBase verwenden, können direkt auf Daten zugreifen, indem sie auf einen Zeilenschlüssel zugreifen, eine Reihe von Zeilenschlüsseln durchsuchen oder die Stapelverarbeitung über MapReduce verwenden.

Grundlagenforschung

Sie können mit den berühmten (für Geeks) Big Data White Papers vertraut sein oder auch nicht. Diese White Papers wurden zwischen 2003 und 2006 von Google Research veröffentlicht und präsentierten die Forschung für drei Säulen des Hadoop-Ökosystems, wie wir es kennen:

  • Google File System (GFS): Das Hadoop Distributed File System (HDFS) ist eine Open Source-Implementierung des GFS und definiert, wie Daten auf einen Cluster von Commodity-Computern verteilt werden.
  • MapReduce: Ein funktionales Programmierparadigma zur Analyse von Daten, die über einen HDFS-Cluster verteilt sind.
  • Bigtable: Ein verteiltes Speichersystem zur Verwaltung strukturierter Daten, das auf sehr große Größen skaliert werden kann - Petabyte an Daten auf Tausenden von Standardmaschinen. HBase ist eine Open Source-Implementierung von Bigtable.

Überbrückung der NoSQL-Lücke: Apache Phoenix

Apache Phoenix ist ein Apache-Projekt der obersten Ebene, das eine SQL-Schnittstelle zu HBase bereitstellt und HBase-Modelle einer relationalen Datenbankwelt zuordnet. Natürlich bietet HBase eine eigene API und Shell für die Ausführung von Funktionen wie Scannen, Abrufen, Ablegen, Auflisten usw., aber mehr Entwickler sind mit SQL vertraut als mit NoSQL. Das Ziel von Phoenix ist es, eine allgemein verständliche Schnittstelle für HBase bereitzustellen.

In Bezug auf die Funktionen macht Phoenix Folgendes:

  • Bietet einen JDBC-Treiber für die Interaktion mit HBase.
  • Unterstützt einen Großteil des ANSI SQL-Standards.
  • Unterstützt DDL-Operationen wie CREATE TABLE, DROP TABLE und ALTER TABLE.
  • Unterstützt DML-Operationen wie UPSERT und DELETE.
  • Kompiliert SQL-Abfragen in native HBase-Scans und ordnet die Antwort dann JDBC ResultSets zu.
  • Unterstützt versionierte Schemas.

Phoenix unterstützt nicht nur eine Vielzahl von SQL-Vorgängen, sondern ist auch sehr leistungsfähig. Es analysiert SQL-Abfragen, unterteilt sie in mehrere HBase-Scans und führt sie parallel aus, wobei die native API anstelle von MapReduce-Prozessen verwendet wird.

Phoenix verwendet zwei Strategien - Co-Prozessoren und benutzerdefinierte Filter -, um Berechnungen näher an die Daten heranzuführen:

  • Co-Prozessoren führen Vorgänge auf dem Server aus, wodurch die Client / Server-Datenübertragung minimiert wird.
  • Benutzerdefinierte Filter reduzieren die Datenmenge, die in einer Abfrageantwort vom Server zurückgegeben wird, wodurch die Menge der übertragenen Daten weiter reduziert wird. Benutzerdefinierte Filter werden auf verschiedene Arten verwendet:
    1. Bei der Ausführung einer Abfrage kann ein benutzerdefinierter Filter verwendet werden, um nur die wesentlichen Spaltenfamilien zu identifizieren, die zur Erfüllung der Suche erforderlich sind.
    2. Ein Skip-Scan-Filter verwendet HBases SEEK_NEXT_USING_HINT, um schnell von einem Datensatz zum nächsten zu navigieren, wodurch Punktabfragen beschleunigt werden.
    3. Ein benutzerdefinierter Filter kann "die Daten salzen", dh er fügt am Anfang des Zeilenschlüssels ein Hash-Byte hinzu, damit Datensätze schnell gefunden werden können.

Insgesamt nutzt Phoenix den direkten Zugriff auf HBase-APIs, Co-Prozessoren und benutzerdefinierte Filter, um eine Leistung auf Millisekunden-Ebene für kleine Datenmengen und eine Leistung auf zweiter Ebene für große Datenmengen zu erzielen. Vor allem stellt Phoenix diese Funktionen Entwicklern über eine vertraute JDBC- und SQL-Schnittstelle zur Verfügung.

Beginnen Sie mit Phoenix

Um Phoenix nutzen zu können, müssen Sie sowohl HBase als auch Phoenix herunterladen und installieren. Die Phoenix-Download-Seite (und Hinweise zur HBase-Kompatibilität) finden Sie hier.

Herunterladen und einrichten

Zum Zeitpunkt dieses Schreibens ist die neueste Version von Phoenix 4.6.0 und auf der Download-Seite steht, dass 4.x mit HBase Version 0.98.1+ kompatibel ist. In meinem Beispiel habe ich die neueste Version von Phoenix heruntergeladen, die für die Verwendung mit HBase 1.1 konfiguriert ist. Sie finden es im Ordner : phoenix-4.6.0-HBase-1.1/.

Hier ist das Setup:

  1. Download and decompress this archive and then use one of the recommended mirror pages here to download HBase. For instance, I selected a mirror, navigated into the 1.1.2 folder, and downloaded hbase-1.1.2-bin.tar.gz.
  2. Decompress this file and create an HBASE_HOME environment variable that points to it; for example, I added the following to my ~/.bash_profile file (on Mac): export HBASE_HOME=/Users/shaines/Downloads/hbase-1.1.2.

Integrate Phoenix with HBase

The process to integrate Phoenix into HBase is simple:

  1. Copy the following file from the Phoenix root directory to the HBase lib directory: phoenix-4.6.0-HBase-1.1-server.jar.
  2. Start HBase by executing the following script from HBase's bin directory:./start-hbase.sh.
  3. With HBase running, test that Phoenix is working by executing the SQLLine console, by executing following command from Phoenix's bin directory: ./sqlline.py localhost.

The SQLLine console

sqlline.py is a Python script that starts a console that connects to HBase's Zookeeper address; localhost in this case. You can walk through an example that I am going to summarize in this section here.

First, let's view all of the tables in HBase by executing !table:

 0: jdbc:phoenix:localhost> !tables +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ | TABLE_CAT | TABLE_SCHEM | TABLE_NAME | TABLE_TYPE | REMARKS | +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ | | SYSTEM | CATALOG | SYSTEM TABLE | | | | SYSTEM | FUNCTION | SYSTEM TABLE | | | | SYSTEM | SEQUENCE | SYSTEM TABLE | | | | SYSTEM | STATS | SYSTEM TABLE | | +------------------------------------------+------------------------------------------+------------------------------------------+------------------------------------------+--------------------------+ 

Because this is a new instance of HBase the only tables that exist are system tables. You can create a table by executing a create table command:

 0: jdbc:phoenix:localhost>create table test (mykey integer not null primary key, mycolumn varchar); No rows affected (2.448 seconds) 

This command creates a table named test, with an integer primary key named mykey and a varchar column named mycolumn. Now insert a couple rows by using the upsert command:

 0: jdbc:phoenix:localhost>upsert into test values (1,'Hello'); 1 row affected (0.142 seconds) 0: jdbc:phoenix:localhost>upsert into test values (2,'World!'); 1 row affected (0.008 seconds) 

UPSERTist ein SQL-Befehl zum Einfügen eines Datensatzes, falls dieser nicht vorhanden ist, oder zum Aktualisieren eines Datensatzes, falls vorhanden. In diesem Fall haben wir (1, 'Hallo') und (2, 'Welt!') Eingefügt. Die vollständige Phoenix-Befehlsreferenz finden Sie hier. Fragen Sie abschließend Ihre Tabelle ab, um die Werte anzuzeigen, die Sie durch Ausführen erhöht haben select * from test:

 0: jdbc:phoenix:localhost>select * from test; +------------------------------------------+------------------------------------------+ | MYKEY | MYCOLUMN | +------------------------------------------+------------------------------------------+ | 1 | Hello | | 2 | World! | +------------------------------------------+------------------------------------------+ 2 rows selected (0.111 seconds) 

Wie erwartet sehen Sie die Werte, die Sie gerade eingefügt haben. Wenn Sie die Tabelle bereinigen möchten, führen Sie einen drop table testBefehl aus.