Apache Phoenix : du SQL sur HBase

Apache Phoenix est une extension open-source de Apache HBase qui fournit une couche de requêtes SQL pour les données stockées dans HBase. Phoenix permet ainsi d'interagir sur les tables HBase à l'aide de requêtes SQL standard, sans avoir à écrire de code spécifique à HBase.

Phoenix utilise une approche de traitement en mémoire pour accélérer les requêtes, ce qui en fait un choix attrayant pour les applications nécessitant des performances élevées lors de l'interrogation de données massives. Il exploite également la compression de données pour réduire l'utilisation de l'espace de stockage.

Dans cet article, nous allons voir comment Phoenix est utilisé pour faciliter les requêtes sur des tables HBase.

Requêtes sur les tables HBase

Rappelons que HBase est une base orientée colonne : elle est constituée de tables de données (au même titre qu'une base de données SQL). En revanche, les colonnes pourront êtres différentes en fonctions des lignes.

Le modèle de données d'Apache HBase est un modèle de colonnes distribuées, également appelé modèle de colonnes larges. Ce modèle de données diffère du modèle de lignes et de colonnes des bases de données relationnelles traditionnelles.

Dans HBase, les données sont stockées dans des tables qui sont constituées de familles de colonnes. Chaque famille de colonnes peut contenir un nombre arbitraire de colonnes, qui peuvent être ajoutées ou supprimées de manière dynamique. Les colonnes sont identifiées par un nom, qui est une chaîne de caractères, et sont regroupées dans des familles de colonnes pour faciliter la gestion des données.

Lorsque l'on souhaite faire des requêtes sur des tables HBase, notamment pour récupérer plusieurs lignes d'une table, on utilise la commande scan. La commande scan, comme son nom l'indique, permet de scanner l'intégralité de la table, c'est-à-dire récupérer ou afficher toutes les lignes qui composent la table, ainsi que les colonnes associées.

À lire aussi : découvrez notre formation Data Engineer

Si par exemple, on dispose de la table users avec les familles de colonnes 'users', 'infos', 'events', on peut utiliser la commande suivante pour récupérer l'intégralité des lignes.

scan 'users'

ROW          COLUMN+CELL
 0           column=infos:email, timestamp=1667398963047, value=encoreuneautreadresse@gmail.com
 0           column=infos:first_name, timestamp=1667398870035, value=Jean
 0           column=infos:last_name, timestamp=1667398833989, value=Dupont
 1           column=infos:first_name, timestamp=1667398924511, value=Maxime
 1           column=infos:last_name, timestamp=1667398924536, value=Jumelle
2 row(s)
Took 0.0481 seconds

Bien entendu, cette commande est très lourde, car elle demande de récupérer toutes les données stockées dans tous les DataNodes de HBase. Dans la plupart des cas, on souhaitera alors filtrer sur les lignes ou les colonnes pour ne récupérer que les lignes qui nous intéressent. Au même titre que la clause WHERE sous SQL, l'opération FILTER permet d'ajouter des prédicats, et plus spécifiquement des filtres pour récupérer uniquement certaines lignes qui nous intéressent.

Par exemple, supposons que l'on souhaite récupérer toutes les lignes dont les utilisateurs possèdent une adresse email. Nous pouvons alors utiliser l'opération suivante.

scan 'users', {FILTER => "SingleColumnValueFilter('infos', 'email', !=, 'binary:', true, true)"}

ROW          COLUMN+CELL
 0           column=infos:email, timestamp=1667398963047, value=encoreuneautreadresse@gmail.com
 0           column=infos:first_name, timestamp=1667398870035, value=Jean
 0           column=infos:last_name, timestamp=1667398833989, value=Dupont
1 row(s)
Took 0.0641 seconds

Nous n'obtenons qu'une seule ligne, ce qui est cohérent, car seul le premier utilisateur sur les deux possède une adresse email. Essayons d'analyser le filtre.

Nous utilisons des filtres comme SingleColumnValueFilter qui vont tester une condition d'égalité, inégalité, etc sur une colonne particulière. Nous spécifions dans l'ordre la famille de colonne, la colonne, l'opération et enfin la valeur à tester (ici, binary: signifie valeur nulle).

Requêtes SQL avec Phoenix

Comme nous venons de le voir, les requêtes sur les tables HBase peuvent être complexes à formuler, car elles demandent d'utiliser l'API HBase standard pour déterminer les opérations à réaliser. Il serait donc plus intéressant d'utiliser un langage comme le SQL, d'une part parce qu'il est très utilisé dans les infrastructures IT, mais aussi parce que beaucoup de Data Engineers savent formuler des requêtes SQL.

C'est justement là qu'intervient Apache Phoenix : cet outil permet de convertir des requêtes SQL en requêtes HBase. Phoenix utilise une syntaxe SQL standard pour la création de tables, l'insertion de données, la mise à jour de données et la requête de données. Il prend en charge les fonctions SQL classiques, les agrégations, les jointures et les sous-requêtes.

Le principal avantage, c'est donc de pouvoir communiquer avec HBase uniquement via du SQL, tout en garantissant les principes de base de données transactionnelle. L'autre point intéressant, c'est que Phoenix utilise des techniques de compression, de mise en cache et de parallélisation pour optimiser les performances des requêtes SQL sur les données HBase. Cela permet d'obtenir des temps de réponse rapides pour les requêtes SQL sur de grandes quantités de données, à l'instar de la rapidité par défaut présente sous HBase.

Lorsqu'une requête SQL est requêtée, il y a en réalité une conversion qui est opérée par Phoenix. Cette opération de mappage de requêtes SQL vers les opérations HBase consiste pour Phoenix à analyser la requête et la mapper vers les opérations HBase appropriées. Phoenix utilise des tables système pour stocker des informations sur la structure de la table HBase et pour mappage les colonnes SQL aux familles de colonnes et aux qualificateurs de colonnes HBase.

Phoenix prend également en charge les index pour accélérer les requêtes SQL. Les index sont stockés dans des tables HBase distinctes et sont utilisés pour identifier rapidement les lignes de données correspondant aux critères de recherche.

À lire aussi : découvrez notre formation Data Engineer

Pour interagir avec Phoenix, on peut utiliser la ligne de commande sqlline.py, qui nous permet de rentrer dans le Shell HBase, et d'exécuter des requêtes SQL. Avant de démarrer, commençons par y ajouter la table users_events.

Il est possible de créer une table sous Phoenix afin d'en créer une représentation SQL pour ensuite y importer les données (depuis une table HBase ou à partir d'un fichier CSV).

1CREATE TABLE IF NOT EXISTS users_events (
2    event_id BIGINT NOT NULL,
3    event_time TIMESTAMP,
4    event_type VARCHAR,
5    product_id VARCHAR,
6    category_id VARCHAR,
7    category_code VARCHAR,
8    brand VARCHAR,
9    price FLOAT,
10    user_id VARCHAR,
11    user_session VARCHAR
12    CONSTRAINT users_events_pk PRIMARY KEY (event_id)
13);

La table users_events peut donc être requêtée avec du SQL classique.

1SELECT * FROM users_events LIMIT 10;

+----------+-----------------------+------------+------------+---------------------+----------------+
| EVENT_ID |      EVENT_TIME       | EVENT_TYPE | PRODUCT_ID |     CATEGORY_ID     |            CAT |
+----------+-----------------------+------------+------------+---------------------+----------------+
| 0        | 2019-10-01 00:00:00.0 | view       | 44600062   | 2103807459595387724 |                |
| 1        | 2019-10-01 00:00:00.0 | view       | 3900821    | 2053013552326770905 | appliances.env |
| 2        | 2019-10-01 00:00:01.0 | view       | 17200506   | 2053013559792632471 | furniture.livi |
| 3        | 2019-10-01 00:00:01.0 | view       | 1307067    | 2053013558920217191 | computers.note |
| 4        | 2019-10-01 00:00:04.0 | view       | 1004237    | 2053013555631882655 | electronics.sm |
| 5        | 2019-10-01 00:00:05.0 | view       | 1480613    | 2053013561092866779 | computers.desk |
| 6        | 2019-10-01 00:00:08.0 | view       | 17300353   | 2053013553853497655 |                |
| 7        | 2019-10-01 00:00:08.0 | view       | 31500053   | 2053013558031024687 |                |
| 8        | 2019-10-01 00:00:10.0 | view       | 28719074   | 2053013565480109009 | apparel.shoes. |
| 9        | 2019-10-01 00:00:11.0 | view       | 1004545    | 2053013555631882655 | electronics.sm |
+----------+-----------------------+------------+------------+---------------------+----------------+
10 rows selected (0.064 seconds)

Le principal intérêt c'est surtout de pouvoir formuler des requêtes avec les clauses SQL classiques comme WHERE, ORDER BY ou encore GROUP BY.

1SELECT user_id, COUNT(*) AS num_articles FROM users_events
2WHERE event_type = 'purchase'
3GROUP BY user_id
4ORDER BY num_articles DESC
5LIMIT 10;

+-----------+--------------+
|  USER_ID  | NUM_ARTICLES |
+-----------+--------------+
| 548318522 | 29           |
| 554090147 | 26           |
| 541311429 | 20           |
| 548891541 | 20           |
| 531974857 | 17           |
| 541337272 | 17           |
| 513322839 | 16           |
| 520695559 | 16           |
| 516993548 | 15           |
| 512730829 | 15           |
+-----------+--------------+

Avantages d'Apache Phoenix

Apache Phoenix présente de nombreux avantages lorsque l'on utilise régulièrement HBase pour de nombreux projets.

• Interface SQL : l'interface SQL complète, ce qui facilite l'adoption et l'utilisation pour les développeurs familiers avec le langage SQL, est sans doute l'un des avantages les plus importants. Il permet d'interagir avec les données stockées dans HBase à l'aide de requêtes SQL standard telles que SELECT, INSERT, UPDATE et DELETE, ainsi que des opérations avancées comme les jointures et les agrégations.
• Haute performance : grâce à l'approche de traitement en mémoire, Phoenix exploite la puissance de calcul distribuée pour accélérer les requêtes. Cela permet d'obtenir des performances élevées lors de l'interrogation de grands ensembles de données distribuées. De plus, Phoenix utilise la compression de données pour réduire l'utilisation de l'espace de stockage, ce qui améliore également les performances.
• Scalabilité : Phoenix est conçu pour fonctionner sur des clusters Apache Hadoop et utilise HBase comme système de stockage sous-jacent. Cela lui permet de tirer parti de la scalabilité et de la distribution offertes par Hadoop, ce qui permet de gérer efficacement des volumes de données massifs et d'effectuer des opérations simultanées à grande échelle.
• Intégration avec l'écosystème Hadoop : en s'appuyant sur Hadoop et HBase, Phoenix s'intègre facilement à l'écosystème Hadoop. Il peut fonctionner aux côtés d'autres outils tels que Apache Spark, Apache Hive et Apache Pig, permettant une intégration transparente avec les workflows de traitement de données existants.
• Prise en charge des transactions : pour certaines situations, Phoenix offre la possibilité d'exécuter des transactions ACID (Atomicité, Cohérence, Isolation, Durabilité) sur les données stockées dans HBase. Cela garantit l'intégrité des données et permet des opérations de mise à jour complexes tout en préservant la cohérence.

Apache Phoenix est donc un choix pertinent pour apporter une couche SQL très intéressant sur les environnements HBase.