Tous les produits
Search
Centre de documentation

PolarDB:Instructions

Dernière mise à jour :Aug 31, 2026

Reportez-vous à la section Démarrage rapide pour configurer votre cluster afin de prendre en charge les charges de travail HTAP (Hybrid Transactional/Analytical Processing), ou à la section Utilisation avancée pour personnaliser IMCI selon vos besoins métier spécifiques.

Démarrage rapide

Étape 1 : Ajouter un nœud IMCI en lecture seule

Connectez-vous à la console PolarDB. Dans le volet de navigation de gauche, cliquez sur Cluster List. Sélectionnez la région de votre cluster et localisez-le. Dans la colonne Actions, cliquez sur Add/Remove Node pour ajouter un nœud IMCI en lecture seule.

Remarque
  • Si vous avez déjà ajouté un nœud IMCI en lecture seule lors de l'achat du cluster, ignorez cette étape.

  • Votre cluster doit respecter les prérequis de version pour IMCI. Pour plus d'informations, consultez la rubrique relative au nœud IMCI en lecture seule.

Étape 2 : Configurer le routage des requêtes

Selon vos besoins métier, optez pour un routage automatique ou manuel des requêtes afin d'utiliser IMCI.

  • Routage automatique des requêtes : si vos charges de travail OLTP (Online Transactional Processing) et OLAP (Online Analytical Processing) accèdent à la base de données depuis la même application, routez automatiquement les requêtes en lecture vers des nœuds IMCI en lecture seule ou vers des nœuds de stockage ligne en lecture seule. Ce choix s'appuie sur le coût d'exécution estimé, déterminé par le nombre de lignes analysées.

  • Routage manuel des requêtes : si vos charges de travail OLTP et OLAP accèdent à la base de données depuis des applications distinctes, configurez des endpoints de cluster différents pour chacune d'elles. Acheminez ensuite les requêtes vers les stockages ligne et colonne en assignant des nœuds IMCI en lecture seule et des nœuds de stockage ligne en lecture seule aux nœuds de service associés à ces endpoints.

Routage automatique des requêtes

Sur la page des détails du cluster, accédez à la section Database Connections. Pour l'Cluster Endpoint, définissez l'option Row Store/Column Store Automatic Routing sur Enable.

Remarque

Routage manuel des requêtes

Sur la page des détails du cluster, accédez à la section Database Connections et créez un endpoint personnalisé. Assurez-vous que le Service Node inclut uniquement des read-only IMCI nodes.

Étape 3 : Ajouter un index IMCI

Ajoutez des index IMCI à vos tables manuellement ou automatiquement, selon vos besoins métier.

Important

Pour qu'une requête soit accélérée par IMCI, toutes les colonnes référencées dans l'instruction SQL doivent être entièrement couvertes par un index IMCI.

Manuel

IMCI propose un ensemble complet d'instructions DDL pour ajouter ou supprimer des index IMCI sur les tables métier. Choisissez l'option adaptée à vos besoins :

Syntaxe DDL

Exemple

Créer un index IMCI lors de la création d'une table

-- Add an IMCI for a specific column.
CREATE TABLE <table_name>(
  <column_name_1> INT COMMENT 'COLUMNAR=1',
  <column_name_2> VARCHAR(100)
) ENGINE InnoDB;

-- Add an IMCI for the entire table.
CREATE TABLE <table_name>(
  <column_name_1> INT,
  <column_name_2> VARCHAR(100)
) ENGINE InnoDB COMMENT 'COLUMNAR=1';

Ajouter ou supprimer dynamiquement un index IMCI

-- Add an IMCI for a specific column.
ALTER TABLE <table_name> MODIFY COLUMN <column_name_1> INT COMMENT 'COLUMNAR=1';
               
-- Add an IMCI for the entire table.
ALTER TABLE <table_name> COMMENT 'COLUMNAR=1';

Ajouter ou supprimer des index IMCI par lots au niveau de la base de données ou de la table

-- Add an IMCI for the entire table.
CREATE COLUMNAR INDEX ON <db_name>.<table_name>;

-- Add IMCIs for all tables in a database.
CREATE COLUMNAR INDEX FOR TABLES IN <db_name>;
Remarque
  • Lorsque vous ajoutez un index IMCI, vous pouvez conserver les commentaires existants. Exemple : ALTER TABLE <table_name> COMMENT 'COLUMNAR=1 <original comment>';.

  • Par défaut, lorsque vous ajoutez des index IMCI par lots au niveau de la base de données ou de la table, le commentaire de la table est mis à jour avec 'COLUMNAR=1 <original comment>'.

Automatique

La fonctionnalité AutoIndex permet de créer automatiquement des index IMCI en se basant sur vos requêtes lentes, améliorant ainsi considérablement leur vitesse d'exécution. Cela élimine la nécessité de comprendre et d'optimiser chaque requête lente individuellement. À mesure que la charge de travail de l'application évolue, AutoIndex surveille et ajuste continuellement la stratégie IMCI afin de garantir des performances optimales pour votre cluster PolarDB.

Pour bénéficier des avantages de cette fonctionnalité, il suffit d'Enable AutoIndex sur la page des détails du cluster PolarDB :

Dans la section Configuration, repérez AutoIndex (qui est Disabled par défaut) et cliquez sur Enable à droite.

(Facultatif) Étape 4 : Vérifier la progression de la construction de l'index IMCI

Après avoir ajouté manuellement un index IMCI, vérifiez sa progression de construction. Attendez la fin de la construction pour bénéficier de l'accélération des requêtes.

SELECT * FROM INFORMATION_SCHEMA.IMCI_ASYNC_DDL_STATS;

Exemple : vérifiez si la valeur de la colonne STATUS est Safe to read pour confirmer que l'index IMCI est entièrement construit.

+-------------+------------+---------------------+---------------------+---------------------+--------------+------------------+-----------------+-------------+-------------+-------------+------------+--------------+-----------+-------------------+-----------------+
| SCHEMA_NAME | TABLE_NAME | CREATED_AT          | STARTED_AT          | FINISHED_AT         | STATUS       | APPROXIMATE_ROWS | SCANNED_ROWS    | SCAN_SECOND | SORT_ROUNDS | SORT_SECOND | BUILD_ROWS | BUILD_SECOND | AVG_SPEED | SPEED_LAST_SECOND | ESTIMATE_SECOND |
+-------------+------------+---------------------+---------------------+---------------------+--------------+------------------+-----------------+-------------+-------------+-------------+------------+--------------+-----------+-------------------+-----------------+
| tpch        | lineitem   | 2024-10-21 13:44:02 | 2024-10-21 13:44:02 | 2024-10-21 13:50:11 | Safe to read | 590446240        | 600037902(100%) | 369         | 0           | 0           | 0(0%)      | 0            | 1625058   | 0                 | 0               |
+-------------+------------+---------------------+---------------------+---------------------+--------------+------------------+-----------------+-------------+-------------+-------------+------------+--------------+-----------+-------------------+-----------------+
1 row in set, 1 warning (0.00 sec)

(Facultatif) Étape 5 : Vérifier l'utilisation de l'index IMCI

Un plan d'exécution IMCI s'affiche sous forme d'arborescence horizontale, dont le format diffère nettement de celui d'un plan d'exécution pour le stockage ligne. Utilisez l'instruction EXPLAIN pour afficher le plan d'exécution et déterminer si une instruction SQL peut être accélérée par IMCI. Les exemples suivants illustrent cette différence :

Plan d'exécution IMCI

+----+----------------------------+----------+--------+--------+-----------------------------------------------------------------------------+
| ID | Operator                   | Name     | E-Rows | E-Cost | Extra Info                                                                  |
+----+----------------------------+----------+--------+--------+-----------------------------------------------------------------------------+
|  1 | Select Statement           |          |        |        | IMCI Execution Plan (max_dop = 4, max_query_mem = 858993459)                |
|  2 | └─Sort                     |          |        |        | Sort Key: revenue DESC,o_orderdate ASC                                      |
|  3 |   └─Hash Groupby           |          |        |        | Group Key: (lineitem.L_ORDERKEY, orders.O_ORDERDATE, orders.O_SHIPPRIORITY) |
|  4 |     └─Hash Join            |          |        |        | Join Cond: orders.O_ORDERKEY = lineitem.L_ORDERKEY                          |
|  5 |       ├─Hash Join          |          |        |        | Join Cond: customer.C_CUSTKEY = orders.O_CUSTKEY                            |
|  6 |       │ ├─Table Scan       | customer |        |        | Cond: (C_MKTSEGMENT = "BUILDING")                                           |
|  7 |       │ └─Table Scan       | orders   |        |        | Cond: (O_ORDERDATE < 03/24/1995)                                            |
|  8 |       └─Table Scan         | lineitem |        |        | Cond: (L_SHIPDATE > 03/24/1995)                                             |
+----+----------------------------+----------+--------+--------+-----------------------------------------------------------------------------+
8 rows in set (0.01 sec)

Plan d'exécution du stockage ligne

+----+-------------+----------+------------+------+--------------------+------------+---------+-----------------------------+--------+----------+----------------------------------------------+
| id | select_type | table    | partitions | type | possible_keys      | key        | key_len | ref                         | rows   | filtered | Extra                                        |
+----+-------------+----------+------------+------+--------------------+------------+---------+-----------------------------+--------+----------+----------------------------------------------+
|  1 | SIMPLE      | customer | NULL       | ALL  | PRIMARY            | NULL       | NULL    | NULL                        | 147630 |    10.00 | Using where; Using temporary; Using filesort |
|  1 | SIMPLE      | orders   | NULL       | ref  | PRIMARY,ORDERS_FK1 | ORDERS_FK1 | 4       | tpch100g.customer.C_CUSTKEY |     14 |    33.33 | Using where                                  |
|  1 | SIMPLE      | lineitem | NULL       | ref  | PRIMARY            | PRIMARY    | 4       | tpch100g.orders.O_ORDERKEY  |      4 |    33.33 | Using where                                  |
+----+-------------+----------+------------+------+--------------------+------------+---------+-----------------------------+--------+----------+----------------------------------------------+
3 rows in set, 1 warning (0.00 sec)

Outils d'aide

Lorsque vous utilisez IMCI pour interroger des instructions SQL complexes, vérifiez si certaines colonnes de l'instruction SQL ne sont pas couvertes par un index IMCI. Si vous identifiez des colonnes non couvertes, obtenez les instructions DDL permettant de créer un index IMCI pour l'instruction SQL concernée, ou récupérez par lot les instructions DDL pour créer des index IMCI pour une charge de travail spécifique. Après avoir exécuté les instructions DDL, assurez-vous que toutes les colonnes référencées dans l'instruction SQL sont couvertes par un index IMCI afin d'activer l'accélération des requêtes.

PolarDB fournit les procédures stockées intégrées suivantes :

FAQ

La requête n'utilise pas IMCI

Après avoir ajouté un nœud IMCI en lecture seule, créez également un index IMCI pour toutes les tables interrogées dans l'instruction SQL. L'instruction n'utilise un index IMCI que si son coût d'exécution estimé dépasse un certain seuil. De plus, l'instruction SQL doit être transférée vers un nœud IMCI en lecture seule pour être accélérée. Si une instruction SQL n'utilise pas IMCI, suivez les étapes ci-dessous pour résoudre le problème :

  1. Vérifiez que l'instruction SQL est transférée vers un nœud IMCI en lecture seule.

    • Vérifiez si le Service Node de l'endpoint de base de données inclut un nœud IMCI en lecture seule.

    • Utilisez SQL Explorer pour confirmer que l'instruction SQL est transférée vers un nœud IMCI en lecture seule.

    Si vous utilisez un Cluster Endpoint avec l'option Service Node activée, et que le coût d'exécution estimé de l'instruction SQL est supérieur au seuil loose_imci_ap_threshold ou loose_cost_threshold_for_imci, PolarProxy transfère l'instruction SQL vers un nœud IMCI en lecture seule. Vous pouvez également ajouter la syntaxe HINT /*FORCE_IMCI_NODES*/ avant le mot-clé SELECT pour forcer le routage de l'instruction SQL vers un nœud IMCI en lecture seule. Pour plus d'informations, consultez la rubrique Configurer le seuil de routage automatique. Exemple :

    Dans les versions mineures du moteur de base de données 8.0.1.1.39 et 8.0.2.2.23 et ultérieures, le paramètre loose_imci_ap_threshold est obsolète et remplacé par le paramètre loose_cost_threshold_for_imci .
    /*FORCE_IMCI_NODES*/EXPLAIN SELECT COUNT(*) FROM t1 WHERE t1.a > 1;
    La création d'un nouvel endpoint de base de données garantit que les instructions SQL sont toujours routées vers des nœuds IMCI en lecture seule pour leur exécution. Pour plus d'informations, consultez la rubrique Créer un nouvel endpoint de base de données .
  2. Vérifiez si le coût d'exécution estimé de l'instruction SQL dépasse le seuil configuré.

    Sur un nœud IMCI en lecture seule, l'optimiseur estime le coût d'exécution d'une instruction SQL. Si le coût d'exécution estimé dépasse le seuil défini par loose_imci_ap_threshold ou loose_cost_threshold_for_imci, l'optimiseur utilise un index IMCI. Sinon, il utilise les index basés sur les lignes existants.

    Après avoir confirmé qu'une instruction SQL est transférée vers un nœud IMCI en lecture seule, si le plan d'exécution affiché via EXPLAIN n'utilise toujours pas l'index IMCI, comparez le coût d'exécution estimé avec le seuil prédéfini pour déterminer si l'index IMCI n'a pas été utilisé parce que le coût d'exécution estimé était trop faible. Interrogez la variable Last_query_cost_for_imci pour obtenir le coût d'exécution estimé de la précédente instruction SQL :

    -- Use EXPLAIN to view the execution plan of the SQL statement.
    EXPLAIN SELECT * FROM t1;
    -- Get the estimated execution cost of the previous query.
    SHOW STATUS LIKE 'Last_query_cost_for_imci';
    Si vous utilisez un endpoint de cluster pour vous connecter à la base de données, nous vous recommandons d'ajouter la syntaxe HINT /*ROUTE_TO_LAST_USED*/ avant SHOW STATUS LIKE 'Last_query_cost_for_imci' . Cela garantit que vous pouvez interroger le coût d'exécution estimé de la précédente instruction sur le nœud correct. Par exemple, /*ROUTE_TO_LAST_USED*/SHOW STATUS LIKE 'Last_query_cost_for_imci';

    Si le coût d'exécution estimé de l'instruction SQL est inférieur au seuil configuré, envisagez d'ajuster la valeur de loose_imci_ap_threshold ou loose_cost_threshold_for_imci. Par exemple, vous pouvez utiliser un HINT pour ajuster le seuil pour une seule instruction SQL :

    /*FORCE_IMCI_NODES*/EXPLAIN SELECT /*+ SET_VAR(cost_threshold_for_imci=0) */ COUNT(*) FROM t1 WHERE t1.a > 1;
  3. Vérifiez que toutes les tables et colonnes de l'instruction SQL sont entièrement couvertes par un index IMCI.

    Appelez la procédure stockée intégrée dbms_imci.check_columnar_index('<query_string>') pour vérifier si un index IMCI a été créé pour les tables ou les colonnes d'une instruction SQL. Pour plus d'informations, consultez la rubrique Vérifier si un index IMCI a été créé pour les tables ou les colonnes d'une instruction SQL. Exemple :

    CALL dbms_imci.check_columnar_index('SELECT COUNT(*) FROM t1 WHERE t1.a > 1');

    Si l'instruction SQL n'est pas entièrement couverte par un index IMCI, l'appel de cette procédure stockée renvoie les tables et colonnes non couvertes. Créez un index IMCI pour chaque table et colonne renvoyée. Si l'instruction est entièrement couverte, la procédure renvoie un ensemble de résultats vide.

  4. Vérifiez la présence de fonctionnalités SQL non prises en charge.

    Consultez les limitations d'utilisation de la syntaxe IMCI pour confirmer si une fonctionnalité SQL spécifique prend en charge IMCI. Pour plus d'informations, consultez la rubrique Limitations d'utilisation de la syntaxe IMCI.

Si l'instruction SQL n'utilise toujours pas IMCI après avoir effectué les vérifications précédentes, consultez le guide d'utilisation pour obtenir de l'aide ou nous contacter .

Pour plus d'informations, consultez la FAQ IMCI.

Utilisation avancée

Consultez les rubriques suivantes pour optimiser votre utilisation d'IMCI.

Fonctionnalité avancée

Description

Définir une clé de tri pour un index IMCI

IMCI organise les données en groupes de lignes. Dans chaque groupe, différentes colonnes sont regroupées en blocs de données colonne. Ces blocs sont construits en parallèle selon l'ordre de la clé primaire des données ligne d'origine, ce qui entraîne un état global non trié. Configurez une clé de tri pour réorganiser les blocs de données colonne et améliorer les performances des requêtes.

Analyser efficacement les données JSON

IMCI intègre un ensemble de fonctionnalités telles que JSON colonne, colonnes virtuelles, DDL instantané et extension du nombre de colonnes pour gérer l'analyse de données structurées et semi-structurées à grande échelle.

Accélérer les processus ETL avec IMCI

La fonctionnalité ETL (Extract, Transform, Load) vous permet d'utiliser IMCI sur un nœud en lecture-écriture (RW). Les requêtes SELECT émises sur le nœud RW sont envoyées à un nœud IMCI en lecture seule pour des requêtes accélérées. Une fois les données lues, le système les transfère vers le nœud RW via le réseau interne et les écrit dans la table de destination.

Activer Serverless pour les nœuds IMCI en lecture seule

La fonctionnalité Serverless met automatiquement à l'échelle les ressources à la hausse et à la baisse en fonction de votre charge de travail. Elle augmente la capacité pendant les heures de pointe pour gérer les pics de charge, et la réduit pendant les heures creuses pour diminuer les coûts.

Accélérer les requêtes sur les tables larges avec Hybrid Plan

Un Hybrid Plan utilise à la fois des index colonne et ligne dans la même requête. Hybrid Plan peut améliorer considérablement les performances des requêtes sur les tables larges. Dans le plan d'exécution, les parties bénéficiant des index colonne sont exécutées sur IMCI et produisent des résultats intermédiaires contenant uniquement les clés primaires. Ensuite, les colonnes requises sont récupérées et renvoyées en utilisant les clés primaires avec l'index primaire InnoDB.

Accélérer l'analyse de volumes massifs de données avec MPP multi-nœuds

Pour les requêtes complexes sur de vastes volumes de données, un seul nœud IMCI en lecture seule peut ne pas répondre aux exigences de performance. Utilisez le traitement parallèle multi-nœuds (MPP) pour accélérer les requêtes.

Pour aller plus loin

Pour en savoir plus sur les principes sous-jacents à IMCI, consultez les documents suivants :