Comblez le fossé SQL-NoSQL avec Apache Phoenix

Apache Phoenix est un projet Java open source relativement nouveau qui fournit un pilote JDBC et un accès SQL à la base de données NoSQL de Hadoop: HBase. Il a été créé en tant que projet interne chez Salesforce, open source sur GitHub, et est devenu un projet Apache de haut niveau en mai 2014. Si vous avez de solides compétences en programmation SQL et que vous souhaitez pouvoir les utiliser avec une puissante base de données NoSQL, Phoenix pourrait être exactement ce que vous recherchez!

Ce didacticiel présente aux développeurs Java Apache Phoenix. Puisque Phoenix s'exécute sur HBase, nous commencerons par un aperçu de HBase et de ses différences avec les bases de données relationnelles. Vous apprendrez comment Phoenix comble le fossé entre SQL et NoSQL, et comment il est optimisé pour interagir efficacement avec HBase. Une fois ces bases éliminées, nous passerons le reste de l'article à apprendre à travailler avec Phoenix. Vous allez configurer et intégrer HBase et Phoenix, créer une application Java qui se connecte à HBase via Phoenix, et vous allez écrire votre première table, insérer des données et exécuter quelques requêtes dessus.

Quatre types de magasin de données NoSQL

Il est intéressant (et quelque peu ironique) que les magasins de données NoSQL soient classés par une fonctionnalité qui leur manque, à savoir SQL. Les magasins de données NoSQL sont disponibles en quatre versions générales:

  1. Les magasins de clés / valeurs mappent une clé spécifique à une valeur, qui peut être un document, un tableau ou un type simple. Des exemples de magasins de clés / valeurs incluent Memcached, Redis et Riak.
  2. Les magasins de documents gèrent des documents, qui sont généralement des structures sans schéma, comme JSON, qui peuvent être d'une complexité arbitraire. La plupart des magasins de documents prennent en charge les index principaux ainsi que les index secondaires et les requêtes complexes. Des exemples de magasins de documents incluent MongoDB et CouchBase.
  3. Les bases de données de graphes se concentrent principalement sur les relations entre les objets dans lesquels les données sont stockées dans les nœuds et dans les relations entre les nœuds. Un exemple de base de données de graphes est Neo4j.
  4. Les bases de données orientées colonnes stockent les données sous forme de sections de colonnes de données plutôt que de lignes de données. HBase est une base de données orientée colonnes, tout comme Cassandra.

HBase: une amorce

Apache HBase est une base de données NoSQL qui s'exécute sur Hadoop en tant que magasin Big Data distribué et évolutif. HBase est une base de données orientée colonnes qui exploite les capacités de traitement distribué du système de fichiers distribués Hadoop (HDFS) et le paradigme de programmation MapReduce de Hadoop. Il a été conçu pour héberger de grandes tables avec des milliards de lignes et potentiellement des millions de colonnes, toutes exécutées sur un cluster de matériel de base.

Apache HBase combine la puissance et l'évolutivité de Hadoop avec la capacité d'interroger des enregistrements individuels et d'exécuter des processus MapReduce.

En plus des capacités héritées de Hadoop, HBase est une base de données puissante à part entière: elle combine des requêtes en temps réel avec la vitesse d'un magasin de clés / valeurs, une stratégie d'analyse de table robuste pour localiser rapidement les enregistrements, et elle prend en charge le traitement par lots. en utilisant MapReduce. En tant que tel, Apache HBase combine la puissance et l'évolutivité de Hadoop avec la possibilité d'interroger des enregistrements individuels et d'exécuter des processus MapReduce.

Le modèle de données HBase

HBase organise les données différemment des bases de données relationnelles traditionnelles, prenant en charge un modèle de données à quatre dimensions dans lequel chaque «cellule» est représentée par quatre coordonnées:

  1. Clé de ligne : chaque ligne a une clé de ligne unique qui est représentée en interne par un tableau d'octets, mais qui n'a aucun type de données formel.
  2. Famille de colonnes : les données contenues dans une ligne sont partitionnées en familles de colonnes ; chaque ligne a le même ensemble de familles de colonnes, mais chaque famille de colonnes n'a pas besoin de conserver le même ensemble de qualificatifs de colonne. Vous pouvez considérer les familles de colonnes comme étant similaires aux tables d'une base de données relationnelle.
  3. Qualificateur de colonne : ils sont similaires aux colonnes d'une base de données relationnelle.
  4. Version : chaque colonne peut avoir un nombre configurable de versions . Si vous demandez les données contenues dans une colonne sans spécifier de version, vous recevez la dernière version, mais vous pouvez demander des versions plus anciennes en spécifiant un numéro de version.

La figure 1 montre comment ces coordonnées à quatre dimensions sont liées.

Steven Haines

Le modèle de la figure 1 montre qu'une ligne est composée d'une clé de ligne et d'un nombre arbitraire de familles de colonnes. Chaque clé de ligne est associée à une collection de «lignes dans les tables», chacune ayant ses propres colonnes. Bien que chaque table doit exister, les colonnes des tables peuvent être différentes d'une ligne à l'autre. Chaque famille de colonnes a un ensemble de colonnes et chaque colonne a un ensemble de versions qui correspondent aux données réelles de la ligne.

Si nous modélisions une personne, la clé de ligne pourrait être le numéro de sécurité sociale de la personne (pour l'identifier de manière unique), et nous pourrions avoir des familles de colonnes comme l'adresse, l'emploi, l'éducation, etc. À l'intérieur de la famille de colonnes d' adresse , nous pouvons avoir des colonnes de rue, de ville, d'état et de code postal, et chaque version peut correspondre à l'endroit où la personne a vécu à un moment donné. La dernière version pourrait indiquer la ville «Los Angeles», tandis que la version précédente pourrait indiquer «New York». Vous pouvez voir cet exemple de modèle dans la figure 2.

Steven Haines

En résumé, HBase est une base de données orientée colonnes qui représente des données dans un modèle à quatre dimensions. Il est construit sur le système de fichiers distribués Hadoop (HDFS), qui partitionne les données sur des milliers de machines de base. Les développeurs utilisant HBase peuvent accéder directement aux données en accédant à une clé de ligne, en analysant une plage de clés de ligne ou en utilisant le traitement par lots via MapReduce.

Recherche fondamentale

Vous connaissez peut-être ou non les célèbres livres blancs (pour les geeks) sur le Big Data. Publié par Google Research entre 2003 et 2006, ces livres blancs présentaient la recherche pour trois piliers de l'écosystème Hadoop tel que nous le connaissons:

  • Système de fichiers Google (GFS): Le système de fichiers distribués Hadoop (HDFS) est une implémentation open source du GFS et définit la façon dont les données sont distribuées sur un cluster de machines de base.
  • MapReduce: un paradigme de programmation fonctionnel pour analyser les données distribuées sur un cluster HDFS.
  • Bigtable: un système de stockage distribué pour la gestion des données structurées qui est conçu pour évoluer vers de très grandes tailles - pétaoctets de données sur des milliers de machines courantes. HBase est une implémentation open source de Bigtable.

Combler le fossé NoSQL: Apache Phoenix

Apache Phoenix est un projet Apache de haut niveau qui fournit une interface SQL à HBase, mappant les modèles HBase à un monde de base de données relationnelle. Bien sûr, HBase fournit sa propre API et son propre shell pour exécuter des fonctions telles que scan, get, put, list, etc., mais plus de développeurs connaissent SQL que NoSQL. Le but de Phoenix est de fournir une interface couramment comprise pour HBase.

En termes de fonctionnalités, Phoenix fait ce qui suit:

  • Fournit un pilote JDBC pour interagir avec HBase.
  • Prend en charge une grande partie de la norme ANSI SQL.
  • Prend en charge les opérations DDL telles que CREATE TABLE, DROP TABLE et ALTER TABLE.
  • Prend en charge les opérations DML telles que UPSERT et DELETE.
  • Compile les requêtes SQL en analyses HBase natives, puis mappe la réponse aux ResultSets JDBC.
  • Prend en charge les schémas versionnés.

En plus de prendre en charge un vaste ensemble d'opérations SQL, Phoenix est également très performant. Il analyse les requêtes SQL, les décompose en plusieurs analyses HBase et les exécute en parallèle, en utilisant l'API native au lieu des processus MapReduce.

Phoenix utilise deux stratégies - co-processeurs et filtres personnalisés - pour rapprocher les calculs des données:

  • Les coprocesseurs effectuent des opérations sur le serveur, ce qui minimise le transfert de données client / serveur.
  • Les filtres personnalisés réduisent la quantité de données renvoyées dans une réponse à une requête du serveur, ce qui réduit encore la quantité de données transférées. Les filtres personnalisés sont utilisés de plusieurs manières:
    1. Lors de l'exécution d'une requête, un filtre personnalisé peut être utilisé pour identifier uniquement les familles de colonnes essentielles requises pour satisfaire la recherche.
    2. Un filtre de balayage de saut utilise SEEK_NEXT_USING_HINT de HBase pour naviguer rapidement d'un enregistrement à l'autre, ce qui accélère les requêtes ponctuelles.
    3. Un filtre personnalisé peut «saler les données», ce qui signifie qu'il ajoute un octet de hachage au début de la clé de ligne afin de pouvoir localiser rapidement les enregistrements.

En résumé, Phoenix exploite un accès direct aux API HBase, aux coprocesseurs et aux filtres personnalisés pour vous offrir des performances de niveau milliseconde pour les petits ensembles de données et des performances de second niveau pour les énormes. Par-dessus tout, Phoenix expose ces capacités aux développeurs via une interface JDBC et SQL familière.

Commencez avec Phoenix

Pour utiliser Phoenix, vous devez télécharger et installer à la fois HBase et Phoenix. Vous pouvez trouver la page de téléchargement de Phoenix (et les notes de compatibilité HBase) ici.

Télécharger et configurer

Au moment d'écrire ces lignes, la dernière version de Phoenix est 4.6.0 et la page de téléchargement indique que 4.x est compatible avec la version 0.98.1+ de HBase. Pour mon exemple, j'ai téléchargé la dernière version de Phoenix qui est configurée pour fonctionner avec HBase 1.1. Vous pouvez le trouver dans le dossier: phoenix-4.6.0-HBase-1.1/.

Voici la configuration:

  1. Téléchargez et décompressez cette archive, puis utilisez l'une des pages miroir recommandées ici pour télécharger HBase. Par exemple, j'ai sélectionné un miroir, navigué dans le dossier 1.1.2 et téléchargé hbase-1.1.2-bin.tar.gz.
  2. Décompressez ce fichier et créez une HBASE_HOMEvariable d'environnement qui pointe vers lui; par exemple, j'ajouté ce qui suit à mon ~/.bash_profilefichier (sur Mac): export HBASE_HOME=/Users/shaines/Downloads/hbase-1.1.2.

Intégrez Phoenix avec HBase

Le processus d'intégration de Phoenix dans HBase est simple:

  1. Copiez le fichier suivant dans le répertoire racine de Phoenix au HBase librépertoire: phoenix-4.6.0-HBase-1.1-server.jar.
  2. Démarrez HBase en exécutant le script suivant à partir de HBase binrépertoire: ./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) 

UPSERTest une commande SQL permettant d'insérer un enregistrement s'il n'existe pas ou de mettre à jour un enregistrement s'il existe. Dans ce cas, nous avons inséré (1, 'Hello') et (2, 'World!'). Vous pouvez trouver la référence complète de la commande Phoenix ici. Enfin, interrogez votre table pour voir les valeurs que vous avez insérées en exécutant select * from test:

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

Comme prévu, vous verrez les valeurs que vous venez d'insérer. Si vous souhaitez nettoyer la table, exécutez une drop table testcommande.