Compression HCC Exadata

Hybrid Columnar Compression (HCC) est une technologie de compression avancée introduite par Oracle, particulièrement conçue pour des environnements tels qu'Oracle Exadata.

Contrairement aux bases de données traditionnelles au format ligne-major, HCC organise les données au format colonne-major dans des unités de stockage connues sous le nom d'unités de compression (CU).

Ce format permet à Oracle de compresser les données plus efficacement, ce qui améliore à la fois l'utilisation du stockage et les performances des requêtes, en particulier pour les opérations de lecture intensive telles que l'entreposage et l'archivage de données.

Le CHC se décline en quatre types de compression :

1. Requête basse: Utilise la compression LZO (Lempel-Ziv-Oberhumer), qui offre une décompression rapide mais des taux de compression plus faibles. Elle convient mieux aux scénarios dans lesquels la vitesse est essentielle, en particulier pour l'accès au niveau des lignes.
2. Requête élevée: Utilise la compression ZLIB (Gzip), ce qui permet d'obtenir de meilleurs taux de compression que Query Low, mais nécessite plus d'unité centrale pour la décompression.
3. Archive Low: Utilise une version plus agressive de l'algorithme ZLIB, optimisant la compression par rapport à Query High, mais au prix d'une surcharge CPU encore plus importante.
4. Archive High: Il s'agit de la forme de compression la plus agressive, utilisant l'algorithme Bzip2. Elle offre le taux de compression le plus élevé, mais entraîne également le coût le plus important pour l'unité centrale et convient mieux aux données auxquelles on accède rarement.

Pour utiliser HCC, il doit être activé sur Exadata ou sur certains systèmes de stockage Oracle (comme Oracle ZFS Storage).

Vous pouvez activer le HCC lors de la création d'une table ou en modifiant une table existante.

Voici un exemple :

CREATE TABLE my_table 
COLUMN STORE COMPRESS FOR ARCHIVE HIGH
AS SELECT * FROM source_table;

La compression peut également être appliquée aux partitions d'une table.

Notez que la compression HCC profite principalement aux charges de travail avec de grands ensembles de données en lecture seule, et qu'elle est moins adaptée aux données fréquemment mises à jour en raison de la dégradation potentielle des performances.

En outre, des opérations de chemin direct sont nécessaires pour insérer des données dans les tables compressées HCC.

Les mises à jour des lignes compressées par HCC sont stockées séparément, ce qui nécessite souvent plus de stockage et réduit les avantages de la compression d'origine.

1. Les 4 types de compression du CHC

Voici des exemples de création de tables à l'aide des quatre différents types de compression hybride en colonnes (HCC) dans Oracle :

1. Requête Faible compression

Ce type de compression offre un équilibre entre les performances et le taux de compression, adapté aux accès fréquents et aux temps de réponse plus rapides des requêtes.

CREATE TABLE my_table_query_low
COLUMN STORE COMPRESS FOR QUERY LOW
AS SELECT * FROM source_table;

2. Compression élevée des requêtes

Cette compression permet d'obtenir un taux de compression plus élevé que Query Low, mais avec un surcoût de décompression plus important.

Il convient aux ensembles de données qui sont lus plus souvent mais qui ne nécessitent pas les performances les plus élevées.

CREATE TABLE my_table_query_high
COLUMN STORE COMPRESS FOR QUERY HIGH
AS SELECT * FROM source_table;

3. Archives à faible compression

Cette compression est utilisée lorsque vous devez stocker des données pendant de longues périodes avec une meilleure compression que Query High, tout en conservant des performances décentes lors de l'interrogation.

CREATE TABLE my_table_archive_low
COLUMN STORE COMPRESS FOR ARCHIVE LOW
AS SELECT * FROM source_table;

4. Archive Haute Compression

Il s'agit de la compression la plus agressive, offrant le taux de compression le plus élevé.

Il est idéal pour les données rarement consultées ou archivées.

CREATE TABLE my_table_archive_high
COLUMN STORE COMPRESS FOR ARCHIVE HIGH
AS SELECT * FROM source_table;

Dans ces exemples, chaque tableau est créé à partir d'un tableau existant (table_source), et le type de compression HCC spécifique est appliqué pour optimiser le stockage en fonction du cas d'utilisation.

Le COLONNE STOCKER COMPRESSER applique le niveau de compression HCC souhaité.

5. Comment créer la table_source

Voici un exemple simple CRÉER UNE TABLE pour le table_sourceque nous pouvons utiliser comme tableau de référence pour les exemples de compression HCC.

Ce tableau contient des exemples de colonnes représentant des types de données typiques.

CREATE TABLE source_table (
    id            NUMBER PRIMARY KEY,
    first_name    VARCHAR2(50),
    last_name     VARCHAR2(50),
    email         VARCHAR2(100),
    created_at    DATE,
    amount        NUMBER(10, 2)
);

Le présent table_source contient quelques champs de base : un id, prénom, nom de famille, courriel, date_de_création (pour la date d'entrée), et montant.

Vous pouvez remplir ce tableau avec des données, puis l'utiliser comme base pour appliquer les différents types de compression hybride en colonnes (HCC).

6. Comment remplir la table_source

Pour remplir le table_source avec des millions de lignes dans Oracle, vous pouvez utiliser un bloc PL/SQL combiné avec des boucles et la fonction DBMS_RANDOM pour générer des données aléatoires.

Voici un exemple qui insère 1 million de lignes dans le tableau :

BEGIN
   FOR i IN 1..1000000 LOOP
      INSERT INTO source_table (
         id, first_name, last_name, email, created_at, amount
      )
      VALUES (
         i,
         DBMS_RANDOM.STRING('U', 10),   -- Random first name
         DBMS_RANDOM.STRING('U', 10),   -- Random last name
         DBMS_RANDOM.STRING('U', 10) || '@example.com',  -- Random email
         SYSDATE - DBMS_RANDOM.VALUE(0, 365),   -- Random date in the past year
         ROUND(DBMS_RANDOM.VALUE(1, 10000), 2)  -- Random amount between 1 and 10000
      );
      
      -- Commit every 10,000 rows for performance reasons
      IF MOD(i, 10000) = 0 THEN
         COMMIT;
      END IF;
   END LOOP;
   
   -- Final commit in case the loop ends without hitting a commit
   COMMIT;
END;
/

7. Comment vérifier le type de compression de chaque table

Pour vérifier le type de compression appliqué à chaque table, vous pouvez interroger les vues du dictionnaire de données d'Oracle.

Plus précisément, vous pouvez utiliser la fonction DBA_TABLES vue ou TOUTES LES TABLES pour vérifier l'état d'avancement de la COMPRESSION et COMPRESS_FOR colonnes.

Voici comment vérifier le type de compression pour chaque table :

SELECT table_name, compression, compress_for
FROM dba_tables
WHERE table_name IN ('MY_TABLE_QUERY_LOW', 'MY_TABLE_QUERY_HIGH', 'MY_TABLE_ARCHIVE_LOW', 'MY_TABLE_ARCHIVE_HIGH');

Exemple de sortie :

2. Comment vérifier les avantages de la compression HCC

Pour connaître les avantages de la compression hybride en colonnes (HCC), vous pouvez utiliser plusieurs approches pour mesurer les économies d'espace et comparer l'espace de stockage utilisé avant et après la compression.

Voici quelques méthodes pour évaluer les avantages de la compression :

1. Demande de renseignements DBA_SEGMENTS pour comparer les tailles de tableaux

Vous pouvez vérifier la taille réelle de la table en termes de segments (c'est-à-dire l'espace de stockage utilisé) et comparer la taille des tables avec et sans compression.

SELECT segment_name, segment_type, (bytes)/1024/1024 AS size_mb
FROM dba_segments
WHERE segment_name IN ('MY_TABLE_QUERY_LOW', 'MY_TABLE_QUERY_HIGH', 'MY_TABLE_ARCHIVE_LOW', 'MY_TABLE_ARCHIVE_HIGH');

Cette requête indique la taille (en Mo) de chaque table, ce qui vous permet de comparer l'espace de stockage occupé par chaque table compressée.

2. Paquet DBMS_COMPRESSION

Oracle fournit le DBMS_COMPRESSION pour analyser les économies d'espace réelles réalisées grâce à la compression. Vous pouvez utiliser ce logiciel pour obtenir des informations détaillées sur les taux de compression et leurs avantages. Voici comment vous pouvez l'utiliser :

DECLARE
   blk_compress_ratio   NUMBER;
   blk_comp_ops         NUMBER;
   blk_comp_ratio_rows  NUMBER;
   blk_uncomp_ops       NUMBER;
   blk_uncomp_ratio_rows NUMBER;
BEGIN
   DBMS_COMPRESSION.GET_COMPRESSION_RATIO(
      schema_name         => 'YOUR_SCHEMA_NAME',
      object_name         => 'MY_TABLE_QUERY_LOW',
      subobject_name      => NULL,
      object_type         => DBMS_COMPRESSION.TABLE,
      blk_compress_ratio  => blk_compress_ratio,
      blk_comp_ops        => blk_comp_ops,
      blk_comp_ratio_rows => blk_comp_ratio_rows,
      blk_uncomp_ops      => blk_uncomp_ops,
      blk_uncomp_ratio_rows => blk_uncomp_ratio_rows
   );
   
   DBMS_OUTPUT.PUT_LINE('Compression Ratio: ' || blk_compress_ratio);
   DBMS_OUTPUT.PUT_LINE('Uncompressed Size: ' || blk_uncomp_ops);
   DBMS_OUTPUT.PUT_LINE('Compressed Size: ' || blk_comp_ops);
END;
/

3. Utilisez le conseiller en compression (DBMS_COMPRESSION.ADVISOR)

Oracle's DBMS_COMPRESSION.ADVISOR fournit des estimations sur les prestations de compression que vous pouvez obtenir de la HCC.

Vous pouvez utiliser ce paquet pour vérifier les économies d'espace attendues.

Voici un exemple d'utilisation :

DECLARE
   comp_ratio NUMBER;
   comp_method VARCHAR2(100);
BEGIN
   comp_method := DBMS_COMPRESSION.COMP_FOR_QUERY_HIGH;

   comp_ratio := DBMS_COMPRESSION.ADVISOR (
      schema_name => 'YOUR_SCHEMA',
      table_name  => 'MY_TABLE_QUERY_HIGH',
      compress_for => comp_method
   );
   
   DBMS_OUTPUT.PUT_LINE('Expected Compression Ratio for ' || comp_method || ': ' || comp_ratio);
END;
/

4. Vérifier la compression réelle des rangs

Vous pouvez obtenir la longueur moyenne des lignes avant et après la compression afin d'évaluer l'espace occupé par chaque ligne :

Avant la compression :

SELECT AVG(vsize(id) + vsize(first_name) + vsize(last_name) + vsize(email) + vsize(created_at) + vsize(amount)) AS avg_row_length
FROM source_table;

Après compression :

SELECT AVG(vsize(id) + vsize(first_name) + vsize(last_name) + vsize(email) + vsize(created_at) + vsize(amount)) AS avg_row_length
FROM MY_TABLE_QUERY_HIGH;

5. Contrôler l'utilisation du stockage au fil du temps

Vous pouvez capturer périodiquement des mesures d'utilisation du stockage avant et après le chargement de données dans des tables compressées et comparer l'évolution du stockage pour les tables compressées par rapport aux tables non compressées.

En utilisant ces méthodes, vous pouvez évaluer les économies d'espace et les avantages réels offerts par la compression hybride en colonnes dans votre environnement.

Le DBA_SEGMENTS vous permet de voir les tailles réelles, et la vue DBMS_COMPRESSION fournit une ventilation détaillée des taux de compression.