Tous les produits
Search
Centre de documentation

Hologres:Manage table groups and shards

Dernière mise à jour :Aug 11, 2026

Configurez les Table Groups et le nombre de shards dans Hologres pour équilibrer les performances des requêtes, le débit en écriture et l'efficacité du stockage selon vos charges de travail.

Découvrez comment créer, interroger, modifier et supprimer des Table Groups, ainsi que redistribuer les shards de vos tables lorsque votre charge de travail évolue.

Fonctionnement des Table Groups et des shards

Une instance Hologres organise les données selon une hiérarchie à deux niveaux :

  • Table Group : conteneur logique regroupant une ou plusieurs tables. Toutes les tables d'un même Table Group partagent le même nombre de shards.

  • Shard : unité de distribution des données. Les shards sont répartis sur les Workers (nœuds de calcul) pour permettre un traitement parallèle.

Concept

Rôle

Instance

Contient une ou plusieurs bases de données, chacune disposant d'un ou plusieurs Table Groups

Table Group

Regroupe les tables partageant un même nombre de shards. Les tables impliquées dans des jointures doivent appartenir au même Table Group.

Shard

Répartit les données sur les Workers pour un traitement parallèle

Worker

Nœud de calcul traitant un ou plusieurs shards

Chaque base de données possède un Table Group par défaut dont le nombre de shards correspond aux spécifications de l'instance. Cette configuration par défaut suffit pour la plupart des charges de travail.

Recommandations de configuration

Respectez les consignes suivantes :

  • Utilisez le Table Group par défaut, sauf si votre charge de travail exige un nombre de shards différent. Les nombres de shards par défaut selon la taille de l'instance figurent dans la section Gestion des instances.

  • Instances de grande taille (> 256 UC) : envisagez plusieurs Table Groups pour équilibrer la charge :

    • Volumes de données importants : créez un Table Group distinct avec un nombre de shards plus élevé.

    • Nombreuses petites tables : créez un Table Group distinct avec un nombre de shards plus faible afin de réduire la surcharge au démarrage des requêtes.

  • Les tables jointes doivent appartenir au même Table Group.

  • Ne créez pas un Table Group par table. Cela ajoute une surcharge inutile et provoque une fragmentation.

  • Alignez le nombre de shards sur les Workers. Définissez le nombre de shards comme un multiple du nombre de Workers pour optimiser l'utilisation des ressources et faciliter la mise à l'échelle horizontale.

Important

Il est impossible de modifier le nombre de shards d'un Table Group existant. Pour changer ce paramètre, créez un nouveau Table Group et redistribuez-y vos tables.

Limites du nombre de shards

À partir de Hologres V2.0, des plafonds par défaut évitent les échecs d'allocation liés à un excès de shards. Le dépassement de ces plafonds renvoie l'erreur too many shards in this instance.

Ces plafonds obéissent aux formules suivantes :

  • Nombre maximal de shards par Table Group = Nombre de shards par défaut x 2

  • Nombre total maximal de shards par instance = Nombre de shards par défaut x 8

Spécifications de l'instance

Nœuds de calcul par défaut

Shards par défaut (V0.10.31+)

Nombre maximal de shards par Table Group (V2.0+)

Nombre maximal de shards par instance (V2.0+)

32 UC

2

20

40 (20 x 2)

160 (20 x 8)

64 UC

4

40

80 (40 x 2)

320 (40 x 8)

96 UC

6

60

120 (60 x 2)

480 (60 x 8)

128 UC

8

80

160 (80 x 2)

640 (80 x 8)

160 UC

10

80

160 (80 x 2)

640 (80 x 8)

192 UC

12

80

160 (80 x 2)

640 (80 x 8)

256 UC

16

120

240 (120 x 2)

960 (120 x 8)

384 UC

24

160

320 (160 x 2)

1280 (160 x 8)

512 UC

32

160

320 (160 x 2)

1280 (160 x 8)

...

...

M

M x 2

M x 8

Pour désactiver ces plafonds (déconseillé, car cela peut entraîner des échecs d'allocation des ressources) :

SET hg_experimental_enable_shard_count_cap = off;

Autorisations

Seul un superutilisateur peut créer, modifier ou supprimer un Table Group, ou déplacer une table vers un autre Table Group (redistribution).

Pour accorder les privilèges de superutilisateur à un utilisateur :

-- Replace <Alibaba Cloud account ID> with the user's UID.
-- For a RAM user, add the prefix "p4_" to the account ID.
ALTER USER "<Alibaba Cloud account ID>" SUPERUSER;

L'affectation d'une nouvelle table à un Table Group requiert uniquement les autorisations de création de table.

Interroger les métadonnées des Table Groups

Afficher le Table Group par défaut

SELECT * FROM hologres.hg_table_group_properties
WHERE tablegroup_name IN (
  SELECT tablegroup_name FROM hologres.hg_table_group_properties
  WHERE property_key = 'is_default_tg' AND property_value = '1'
);

Exemple de sortie :

 tablegroup_name |   property_key   | property_value
-----------------+------------------+----------------
 test_tg_default | tg_version       | 1
 test_tg_default | table_num        | 1
 test_tg_default | is_default_tg    | 1
 test_tg_default | shard_count      | 3
 test_tg_default | replica_count    | 1
 test_tg_default | created_manually | 0
(6 rows)

Dans cette sortie, is_default_tg identifie le Table Group par défaut et shard_count indique son nombre de shards.

Lister tous les Table Groups

SELECT tablegroup_name
FROM hologres.hg_table_group_properties GROUP BY tablegroup_name;

Afficher le nombre de shards d'un Table Group

SELECT property_value AS shard_count
FROM hologres.hg_table_group_properties
WHERE property_key = 'shard_count' AND tablegroup_name = '<tg_name>';

Lister les tables d'un Table Group

SELECT table_namespace AS schema_name, table_name
FROM hologres.hg_table_properties
WHERE property_key = 'table_group' AND property_value = '<tg_name>';

Trouver le Table Group associé à une table

SELECT property_value AS table_group_name
FROM hologres.hg_table_properties
WHERE property_key = 'table_group' AND table_name = '<table_name>';

Créer un Table Group

CALL HG_CREATE_TABLE_GROUP('<new_tg_name>', <shard_count>);

Paramètre

Type

Description

new_tg_name

Text

Nom du Table Group

shard_count

INT4

Nombre de shards du Table Group

Exemple :

-- Create a Table Group named tg_8 with 8 shards.
CALL HG_CREATE_TABLE_GROUP('tg_8', 8);
Remarque
  • Les tables existantes restent dans leur Table Group d'origine.

  • Le Table Group d'origine devient invalide uniquement après le déplacement ou la suppression de toutes ses tables et données.

Modifier le Table Group par défaut

Définissez un autre Table Group par défaut afin que les nouvelles tables lui soient automatiquement attribuées.

Remarque

Requiert Hologres V0.9 ou version ultérieure. Si votre instance utilise une version antérieure, mettez-la à niveau au préalable.

CALL HG_UPDATE_DATABASE_PROPERTY('default_table_group', '<tg_name>');

Paramètre

Type

Description

tg_name

TEXT

Nom du Table Group à définir comme valeur par défaut. Son nombre de shards devient la nouvelle valeur par défaut pour la base de données.

Exemple :

-- Set tg_8 as the default Table Group.
CALL HG_UPDATE_DATABASE_PROPERTY('default_table_group', 'tg_8');

Affecter une nouvelle table à un Table Group spécifique

Englobez les appels CREATE TABLE et SET_TABLE_PROPERTY dans une transaction :

BEGIN;
CREATE TABLE <table_name> (
    col1 text,
    ...
);
CALL SET_TABLE_PROPERTY('<table_name>', 'table_group', '<tg_name>');
COMMIT;

Paramètre

Type

Description

table_name

TEXT

Nom de la nouvelle table

tg_name

TEXT

Table Group cible. La table hérite du nombre de shards de ce Table Group.

Exemple :

-- Create table tbl1 and assign it to Table Group tg_8.
BEGIN;
CREATE TABLE tbl1 (
    col1 text
);
CALL SET_TABLE_PROPERTY('tbl1', 'table_group', 'tg_8');
COMMIT;

Redistribuer les shards d'une table

La mise à l'échelle verticale d'une instance n'ajuste pas le nombre de shards des bases de données existantes. Pour exploiter la capacité ajoutée, créez un nouveau Table Group avec un nombre de shards plus élevé et déplacez-y vos tables. Les nouvelles bases de données créées après la mise à l'échelle utilisent la valeur par défaut actualisée. Consultez l'article Présentation des spécifications d'instance.

Trois méthodes sont disponibles :

Méthode

Types de tables pris en charge

Version minimale

Liquid Table

Tables non partitionnées et tables logiquement partitionnées (dynamique ; prise d'effet immédiate sans interruption des lectures ou des écritures)

Hologres V4.2

Commande REBUILD

Tables non partitionnées, physiquement partitionnées et logiquement partitionnées (exécution séquentielle par partition)

Hologres V3.1

Procédure stockée

Tables non partitionnées et tables physiquement partitionnées

Hologres V0.10

Redistribution avec Liquid Table

À partir de Hologres V4.2, une Liquid Table peut être déplacée dynamiquement entre différents Table Groups. La modification prend effet immédiatement, sans interrompre les opérations de lecture ou d'écriture. Pour plus d'informations, consultez la documentation relative aux Liquid Tables.

Redistribution avec REBUILD

À partir de Hologres V3.1, la commande REBUILD permet de déplacer des tables entre Table Groups de manière asynchrone, avec un suivi en temps réel de la progression. Consultez la documentation sur REBUILD (Bêta).

Redistribution via une procédure stockée

À partir de Hologres V0.10, une procédure stockée intégrée permet de déplacer une table vers un nouveau Table Group sans la recréer ni réimporter les données.

Limitations

  • Requiert Hologres V0.10 ou version ultérieure. Vérifiez votre version sur la page Instance Details. Si vous utilisez une version antérieure, mettez votre instance à niveau ou contactez le support en ligne.

  • Interrompez toutes les opérations d'écriture pendant la redistribution. Les lectures ne sont pas affectées. À partir de la V1.1, utilisez set table readonly pour assurer le basculement automatique des tâches d'écriture en temps réel.

  • La redistribution consomme du CPU et augmente temporairement l'espace de stockage. Exécutez cette opération pendant les heures creuses.

  • Désactivez le journal binaire de la table avant la redistribution, puis réactivez-le ensuite. Consultez la rubrique S'abonner aux journaux binaires Hologres.

  • Les tables contenant des champs SERIAL ne peuvent pas être redistribuées. Les tables dotées de valeurs DEFAULT perdent leur attribut DEFAULT après redistribution.

  • La table ne doit dépendre d'aucun autre objet, tel qu'une vue. Supprimez les dépendances avant la redistribution, sinon Hologres renvoie l'erreur suivante : "ERROR: resharding table xxx can not executed because other objects depend on it.". Pour contourner les dépendances de vues, définissez set hg_experimental_hg_insert_overwrite_enable_view=on;.

  • La redistribution s'applique uniquement au modèle d'autorisations simple (SPM). Consultez la documentation sur le modèle d'autorisations Hologres.

  • La redistribution ne préserve pas les propriétés de partitionnement automatique.

  • À partir de Hologres V2.0, les commentaires de colonnes sont conservés lors de la redistribution. Sur les versions antérieures, sauvegardez et restaurez manuellement les commentaires de colonnes.

Syntaxe

Pour la V2.0.24 et les versions ultérieures : utilisez HoloWeb pour effectuer la redistribution via une interface graphique. Consultez la rubrique Redistribution des tables.

Pour les versions antérieures : exécutez les commandes SQL suivantes.

-- For V1.1 and later:
CALL HG_MOVE_TABLE_TO_TABLE_GROUP('<table_name>', '<new_table_group_name>');

-- For V0.10 and later:
CALL HG_UPDATE_TABLE_SHARD_COUNT('<table_name>', '<new_table_group_name>');

Paramètre

Description

Exemple

table_name

Table à déplacer. Pour une table partitionnée, spécifiez la table parente. Exécutez la commande une fois par table.

new_table

new_table_group_name

Table Group cible.

new_tg

Important
  • Créez le nouveau Table Group avant de déplacer les tables. Créer un Table Group.

  • Interrompez toutes les opérations d'écriture sur la table pendant la redistribution. Les lectures ne sont pas affectées.

  • Après avoir déplacé toutes les tables hors d'un Table Group, supprimez manuellement le Table Group vide à l'aide de HG_DROP_TABLE_GROUP s'il n'est plus nécessaire.

  • Pour une table partitionnée, opérez uniquement sur la table parente.

  • Sur une instance Virtual Warehouse, la migration doit être exécutée par le leader Virtual Warehouse du Table Group cible, qui doit également accéder au Table Group source en tant que follower. Consultez la rubrique Autoriser un groupe de calcul à accéder aux données.

Gérer les exceptions de redistribution

La redistribution peut être interrompue par des erreurs OOM (Out Of Memory) ou une terminaison manuelle. En cas d'interruption, la table d'origine devient accessible en lecture seule et une table temporaire nommée <initial_table_name>_xxxxxxxx apparaît.

Pour les instances exécutant la V2.0.24 ou une version ultérieure :

  • HoloWeb : poursuivez ou annulez la redistribution depuis l'interface utilisateur. Consultez la rubrique Redistribution des tables.

  • SQL : suivez les étapes ci-dessous.

Pour les instances exécutant des versions antérieures : Effectuez une mise à niveau vers la V2.0.24 ou une version ultérieure au préalable.

Pour reprendre la redistribution, résolvez la cause racine du problème et exécutez à nouveau la commande HG_MOVE_TABLE_TO_TABLE_GROUP.

Pour annuler la redistribution et restaurer l'état initial, exécutez les commandes suivantes dans l'ordre indiqué :

-- 1. Remove the read-only flag from the original table.
CALL set_table_property('<schema_name>.<table_name>', 'readonly', 'false');

-- 2. Find the temporary table name.
-- For a partitioned table:
SELECT schema_name, target_temp_table_name
FROM hologres.hg_resharding_properties
WHERE reshard_table_name = '<schema_name>.<table_name>' AND is_parent_table IS TRUE;

-- For a non-partitioned table:
SELECT schema_name, target_temp_table_name
FROM hologres.hg_resharding_properties
WHERE reshard_table_name = '<schema_name>.<table_name>'
  AND is_parent_table IS FALSE AND is_sub_table IS FALSE;

-- 3. Drop the temporary table.
DROP TABLE IF EXISTS <schema_name>.<target_temp_table_name>;

-- 4. Clear the resharding progress record.
CALL hologres.hg_internal_clear_resharding_properties('<schema_name>.<table_name>');

Supprimer un Table Group

Supprimez d'abord toutes les tables du Table Group, puis exécutez :

CALL HG_DROP_TABLE_GROUP('<tg_name>');

Exemple :

CALL HG_DROP_TABLE_GROUP('tg_8');

Vérifier la distribution des shards sur les Workers

Une distribution inégale des shards entre les Workers entraîne un déséquilibre de charge et une utilisation inefficace des ressources.

À partir de Hologres V1.3, utilisez la vue système worker_info pour vérifier le mappage des shards sur les Workers. La rubrique Concepts de base décrit la relation entre les shards et les nœuds. La rubrique Interroger la répartition des shards entre les Workers fournit la syntaxe de requête appropriée.

Bonnes pratiques

Le Table Group par défaut convient à la plupart des charges de travail. Les configurations personnalisées sont détaillées dans la rubrique Bonnes pratiques pour la définition des groupes de tables.

FAQ

Que signifie l'erreur « internal error: Get rundown is not allowed in recovering state » ?

Cette erreur indique que la table est en lecture seule, ce qui bloque les opérations INSERT, UPDATE et DELETE. Hologres définit cet état lorsqu'une redistribution est interrompue afin d'éviter toute incohérence des données.

Pour résoudre ce problème :

  1. Identifiez toutes les tables en lecture seule :

       SELECT * FROM hologres.hg_table_properties
       WHERE property_key = 'readonly' AND property_value = 'true';
  2. Supprimez l'indicateur de lecture seule. Remplacez <table_name> par le nom qualifié complet de la table (par exemple, public.my_table).

       CALL set_table_property('<table_name>', 'readonly', 'false');