Test du stockage en colonnes (Columnar Storage)

Comme la plupart d'entre vous le savent probablement déjà, depuis environ la fin de 2022 InterSystems IRIS a inclus la fonctionnalité de stockage de colonnes dans sa base de données, eh bien, dans l'article d'aujourd'hui, nous allons la mettre à l'épreuve par rapport au stockage de rangées habituel.

Stockage de colonnes

Quelle est la principale caractéristique de ce type de stockage? Si nous consultons la documentation officielle, nous verrons ce tableau fantastique qui explique les principales caractéristiques des deux types de stockage (par rangées ou par colonnes):

Comme vous pouvez le constater, le stockage de colonnes est principalement conçu pour les tâches analytiques dans le cadre desquelles des requêtes sont lancées sur des champs spécifiques de notre tableau, tandis que le stockage de rangées est plus optimal lorsqu'un grand nombre d'opérations d'insertion, de mise à jour et de suppression sont nécessaires. ainsi que pour l'obtention d'enregistrements complets.

Si vous continuez la lecture de la documentation, vous verrez à quel point il est simple de configurer notre table pour qu'elle puisse utiliser le stockage de colonnes:

CREATE TABLE table (column type, column2 type2, column3 type3) WITH STORAGETYPE = COLUMNAR

En utilisant cette commande, nous définissons toutes les colonnes de notre tableau avec un stockage de colonnes, mais nous pouvons opter pour un modèle mixte où notre tableau dispose d'un stockage de rangées, mais dont certaines colonnes font appel à un stockage de colonnes.

Ce scénario mixte pourrait être intéressant lorsque des opérations d'agrégation telles que les sommes, les moyennes, etc. sont courantes. Dans un tel cas, nous pourrions définir la colonne qui utilisera le stockage en question:

CREATE TABLE table (column type, column2 type2, column3 type3 WITH STORAGETYPE = COLUMNAR)

Dans l'exemple précédent, nous avons défini une table avec un stockage de rangées et une colonne (column3) avec un stockage de colonnes.

Comparatif

Pour comparer le temps consacré au stockage de colonnes et au stockage de rangées dans des requêtes différentes, nous avons créé un petit exercice à l'aide de Jupyter Notebook qui insère une série d'enregistrements que nous générons dans deux tables, la première avec un stockage de rangées (Test.PurchaseOrderRow) et la seconde avec un stockage de rangées dans les deux colonnes (Test.PurchaseOrderColumnar)

Test.PurchaseOrderRow

CREATE TABLE Test.PurchaseOrderRow (
    Reference INTEGER,
    Customer VARCHAR(225),
    PaymentDate DATE,
    Vat NUMERIC(10,2),
    Amount NUMERIC(10,2),
    Status VARCHAR(10))

Test.PurchaseOrderColumnar

CREATE TABLE Test.PurchaseOrderColumnar (
    Reference INTEGER,
    Customer VARCHAR(225),
    PaymentDate DATE,
    Vat NUMERIC(10,2),
    Amount NUMERIC(10,2) WITH STORAGETYPE = COLUMNAR,
    Status VARCHAR(10) WITH STORAGETYPE = COLUMNAR)

Si vous téléchargez le projet Open Exchange et le déployez dans votre Docker local, vous pouvez accéder à l'instance Jupyter Notebook et examiner le fichier PerformanceTests.ipynb, qui sera responsable de la génération des données aléatoires que nous allons stocker en différentes étapes dans nos tables et enfin il nous montrera un graphique avec la performance des opérations d'interrogation.

Jetons un coup d'œil rapide à la configuration de notre projet:

docker-compose.yml

version: '3.7'
services:
  # iris
  iris:
    init: true
    container_name: iris
    build:
      context: .
      dockerfile: iris/Dockerfile
    ports:
      - 52774:52773
      - 51774:1972
    volumes:
    - ./shared:/shared
    environment:
    - ISC_DATA_DIRECTORY=/shared/durable
    command: --check-caps false --ISCAgent false
  # jupyter notebook
  jupyter:
    build:
      context: .
      dockerfile: jupyter/Dockerfile
    container_name: jupyter
    ports:
      - "8888:8888"
    environment:
      - JUPYTER_ENABLE_LAB=yes
      - JUPYTER_ALLOW_INSECURE_WRITES=true
    volumes:
      - ./jupyter:/home/jovyan
      - ./data:/app/data
    command: "start-notebook.sh --NotebookApp.token='' --NotebookApp.password=''" 

Nous déployons les conteneurs IRIS et Jupyter dans notre docker, en configurant d'abord IRIS avec l'espace de noms "TEST" et les deux tables requises pour le test.

Pour que vous ne vous ennuyiez pas avec du code, vous pouvez consulter le fichier PerformanceTests.ipynb à partir duquel nous allons nous connecter à IRIS, générer les enregistrements à insérer et les stocker dans IRIS

Exécution du test

Les résultats ont été les suivants (en secondes):

Inserts:

Les inserts effectuées sont de type "bulk":

INSERT INTO Test.PurchaseOrderColumnar (Reference, Customer, PaymentDate, Vat, Amount, Status) VALUES (?, ?, ?, ?, ?, ?)

Le temps nécessaire pour chaque insert batch est le suivant:

Sélections:

La sélection lancée inclut une fonction d'agrégation et une condition, toutes deux sur des colonnes avec stockage de colonnes:

SELECT AVG(Amount) FROM Test.PurchaseOrderColumnar WHERE Status = 'SENT'

Conclusions

Comme vous pouvez le voir dans les résultats obtenus, l'opération correspond exactement à ce qui est indiqué dans la documentation. L'inclusion de colonnes avec stockage de colonnes pénalise légèrement les performances au cours des inserts (environ 18% plus lent pour notre exemple) alors que les requêtes sur ces mêmes colonnes améliorent considérablement le temps de réponse (258 fois plus rapide).

Il s'agit sans aucun doute d'un élément à prendre en compte lors de la planification du développement de toute application.