Tous les produits
Search

Ce produit

    Hologres:Quickstart: Use virtual warehouses

    Centre de documentation

    Hologres:Quickstart: Use virtual warehouses

    Dernière mise à jour :Aug 11, 2026

    Hologres V2.0 sépare les ressources de calcul en entrepôts virtuels indépendants pour des déploiements élastiques et hautement disponibles. Ce guide couvre la création d'entrepôts, le chargement des données, l'accès utilisateur et le basculement du trafic.

    Informations générales

    Les entrepôts virtuels offrent l'isolation des ressources, l'élasticité, la séparation lecture/écriture et l'isolation des charges de travail. Architecture des entrepôts virtuels.

    Prérequis

    Seules les instances Hologres de version V2.0.4 ou ultérieure prennent en charge les entrepôts virtuels. Si votre instance exécute une version antérieure à la V2.0.4, consultez Erreurs courantes lors de la préparation de la mise à niveau ou rejoignez le groupe DingTalk Hologres pour obtenir de l'aide. Pour plus d'informations, consultez Comment obtenir davantage de support en ligne ?.

    Créer un nouvel entrepôt virtuel

    Cet exemple crée un entrepôt virtuel nommé read_warehouse_1 pour la séparation lecture/écriture. L'entrepôt init_warehouse gère les écritures, tandis que read_warehouse_1 traite les requêtes.

    image..png

    Créer une base de données

    1. Connectez-vous à HoloWeb en tant que superutilisateur et créez une base de données nommée erp_database. Créer une base de données.

      Dans la boîte de dialogue Create Database, configurez les paramètres suivants :

      • Instance : sélectionnez l'instance cible.

      • Database Name : saisissez un nom de base de données, par exemple erp_database.

      • Permission Policy : sélectionnez SPM.

      • Log On Immediately : sélectionnez Yes. La connexion à une base de données ferme toutes les pages ouvertes sous la base de données actuelle. Assurez-vous d'avoir enregistré votre travail.

      Cliquez sur OK pour finaliser la création.

    2. Connectez-vous à la base de données et exécutez le code SQL suivant pour importer les exemples de données.

      DROP FOREIGN TABLE IF EXISTS odps_customer_10g;
DROP FOREIGN TABLE IF EXISTS odps_lineitem_10g;
DROP FOREIGN TABLE IF EXISTS odps_nation_10g;
DROP FOREIGN TABLE IF EXISTS odps_orders_10g;
DROP FOREIGN TABLE IF EXISTS odps_part_10g;
DROP FOREIGN TABLE IF EXISTS odps_partsupp_10g;
DROP FOREIGN TABLE IF EXISTS odps_region_10g;
DROP FOREIGN TABLE IF EXISTS odps_supplier_10g;

IMPORT FOREIGN SCHEMA "MAXCOMPUTE_PUBLIC_DATA#default" LIMIT to
(
    odps_customer_10g,
    odps_lineitem_10g,
    odps_nation_10g,
    odps_orders_10g,
    odps_part_10g,
    odps_partsupp_10g,
    odps_region_10g,
    odps_supplier_10g
) 
FROM SERVER odps_server INTO public OPTIONS(if_table_exist'error',if_unsupported_type'error');

DROP TABLE IF EXISTS LINEITEM;

BEGIN;
CREATE TABLE LINEITEM
(
    L_ORDERKEY      BIGINT      NOT NULL,
    L_PARTKEY       INT         NOT NULL,
    L_SUPPKEY       INT         NOT NULL,
    L_LINENUMBER    INT         NOT NULL,
    L_QUANTITY      DECIMAL(15,2) NOT NULL,
    L_EXTENDEDPRICE DECIMAL(15,2) NOT NULL,
    L_DISCOUNT      DECIMAL(15,2) NOT NULL,
    L_TAX           DECIMAL(15,2) NOT NULL,
    L_RETURNFLAG    TEXT        NOT NULL,
    L_LINESTATUS    TEXT        NOT NULL,
    L_SHIPDATE      TIMESTAMPTZ NOT NULL,
    L_COMMITDATE    TIMESTAMPTZ NOT NULL,
    L_RECEIPTDATE   TIMESTAMPTZ NOT NULL,
    L_SHIPINSTRUCT  TEXT        NOT NULL,
    L_SHIPMODE      TEXT        NOT NULL,
    L_COMMENT       TEXT        NOT NULL,
    PRIMARY KEY (L_ORDERKEY,L_LINENUMBER)
);
CALL set_table_property('LINEITEM', 'clustering_key', 'L_SHIPDATE,L_ORDERKEY');
CALL set_table_property('LINEITEM', 'segment_key', 'L_SHIPDATE');
CALL set_table_property('LINEITEM', 'distribution_key', 'L_ORDERKEY');
CALL set_table_property('LINEITEM', 'bitmap_columns', 'L_ORDERKEY,L_PARTKEY,L_SUPPKEY,L_LINENUMBER,L_RETURNFLAG,L_LINESTATUS,L_SHIPINSTRUCT,L_SHIPMODE,L_COMMENT');
CALL set_table_property('LINEITEM', 'dictionary_encoding_columns', 'L_RETURNFLAG,L_LINESTATUS,L_SHIPINSTRUCT,L_SHIPMODE,L_COMMENT');
CALL set_table_property('LINEITEM', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS ORDERS;

BEGIN;
CREATE TABLE ORDERS
(
    O_ORDERKEY      BIGINT      NOT NULL PRIMARY KEY,
    O_CUSTKEY       INT         NOT NULL,
    O_ORDERSTATUS   TEXT        NOT NULL,
    O_TOTALPRICE    DECIMAL(15,2) NOT NULL,
    O_ORDERDATE     timestamptz NOT NULL,
    O_ORDERPRIORITY TEXT        NOT NULL,
    O_CLERK         TEXT        NOT NULL,
    O_SHIPPRIORITY  INT         NOT NULL,
    O_COMMENT       TEXT        NOT NULL
);
CALL set_table_property('ORDERS', 'segment_key', 'O_ORDERDATE');
CALL set_table_property('ORDERS', 'distribution_key', 'O_ORDERKEY');
CALL set_table_property('ORDERS', 'bitmap_columns', 'O_ORDERKEY,O_CUSTKEY,O_ORDERSTATUS,O_ORDERPRIORITY,O_CLERK,O_SHIPPRIORITY,O_COMMENT');
CALL set_table_property('ORDERS', 'dictionary_encoding_columns', 'O_ORDERSTATUS,O_ORDERPRIORITY,O_CLERK,O_COMMENT');
CALL set_table_property('ORDERS', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS PARTSUPP;

BEGIN;
CREATE TABLE PARTSUPP
(
    PS_PARTKEY    INT    NOT NULL,
    PS_SUPPKEY    INT    NOT NULL,
    PS_AVAILQTY   INT    NOT NULL,
    PS_SUPPLYCOST DECIMAL(15,2) NOT NULL,
    PS_COMMENT    TEXT   NOT NULL,
    PRIMARY KEY(PS_PARTKEY,PS_SUPPKEY)
);
CALL set_table_property('PARTSUPP', 'distribution_key', 'PS_PARTKEY');
CALL set_table_property('PARTSUPP', 'colocate_with', 'LINEITEM');
CALL set_table_property('PARTSUPP', 'bitmap_columns', 'PS_PARTKEY,PS_SUPPKEY,PS_AVAILQTY,PS_COMMENT');
CALL set_table_property('PARTSUPP', 'dictionary_encoding_columns', 'PS_COMMENT');
CALL set_table_property('PARTSUPP', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS PART;

BEGIN;
CREATE TABLE PART
(
    P_PARTKEY     INT    NOT NULL PRIMARY KEY,
    P_NAME        TEXT   NOT NULL,
    P_MFGR        TEXT   NOT NULL,
    P_BRAND       TEXT   NOT NULL,
    P_TYPE        TEXT   NOT NULL,
    P_SIZE        INT    NOT NULL,
    P_CONTAINER   TEXT   NOT NULL,
    P_RETAILPRICE DECIMAL(15,2) NOT NULL,
    P_COMMENT     TEXT   NOT NULL
);
CALL set_table_property('PART', 'distribution_key', 'P_PARTKEY');
CALL set_table_property('PART', 'bitmap_columns', 'P_PARTKEY,P_SIZE,P_NAME,P_MFGR,P_BRAND,P_TYPE,P_CONTAINER,P_COMMENT');
CALL set_table_property('PART', 'dictionary_encoding_columns', 'P_NAME,P_MFGR,P_BRAND,P_TYPE,P_CONTAINER,P_COMMENT');
CALL set_table_property('PART', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS CUSTOMER;
BEGIN;
CREATE TABLE CUSTOMER
(
    C_CUSTKEY    INT    NOT NULL PRIMARY KEY,
    C_NAME       TEXT   NOT NULL,
    C_ADDRESS    TEXT   NOT NULL,
    C_NATIONKEY  INT    NOT NULL,
    C_PHONE      TEXT   NOT NULL,
    C_ACCTBAL    DECIMAL(15,2) NOT NULL,
    C_MKTSEGMENT TEXT   NOT NULL,
    C_COMMENT    TEXT   NOT NULL
);
CALL set_table_property('CUSTOMER', 'distribution_key', 'C_CUSTKEY');
CALL set_table_property('CUSTOMER', 'bitmap_columns', 'C_CUSTKEY,C_NATIONKEY,C_NAME,C_ADDRESS,C_PHONE,C_MKTSEGMENT,C_COMMENT');
CALL set_table_property('CUSTOMER', 'dictionary_encoding_columns', 'C_NAME,C_ADDRESS,C_PHONE,C_MKTSEGMENT,C_COMMENT');
CALL set_table_property('CUSTOMER', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS SUPPLIER;

BEGIN;
CREATE TABLE SUPPLIER
(
    S_SUPPKEY   INT    NOT NULL PRIMARY KEY,
    S_NAME      TEXT   NOT NULL,
    S_ADDRESS   TEXT   NOT NULL,
    S_NATIONKEY INT    NOT NULL,
    S_PHONE     TEXT   NOT NULL,
    S_ACCTBAL   DECIMAL(15,2) NOT NULL,
    S_COMMENT   TEXT   NOT NULL
);
CALL set_table_property('SUPPLIER', 'distribution_key', 'S_SUPPKEY');
CALL set_table_property('SUPPLIER', 'bitmap_columns', 'S_SUPPKEY,S_NAME,S_ADDRESS,S_NATIONKEY,S_PHONE,S_COMMENT');
CALL set_table_property('SUPPLIER', 'dictionary_encoding_columns', 'S_NAME,S_ADDRESS,S_PHONE,S_COMMENT');
CALL set_table_property('SUPPLIER', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS NATION;

BEGIN;
CREATE TABLE NATION(
  N_NATIONKEY INT NOT NULL PRIMARY KEY,
  N_NAME text NOT NULL,
  N_REGIONKEY INT NOT NULL,
  N_COMMENT text NOT NULL
);
CALL set_table_property('NATION', 'distribution_key', 'N_NATIONKEY');
CALL set_table_property('NATION', 'bitmap_columns', 'N_NATIONKEY,N_NAME,N_REGIONKEY,N_COMMENT');
CALL set_table_property('NATION', 'dictionary_encoding_columns', 'N_NAME,N_COMMENT');
CALL set_table_property('NATION', 'time_to_live_in_seconds', '31536000');
COMMIT;

DROP TABLE IF EXISTS REGION;

BEGIN;
CREATE TABLE REGION
(
    R_REGIONKEY INT  NOT NULL PRIMARY KEY,
    R_NAME      TEXT NOT NULL,
    R_COMMENT   TEXT
);
CALL set_table_property('REGION', 'distribution_key', 'R_REGIONKEY');
CALL set_table_property('REGION', 'bitmap_columns', 'R_REGIONKEY,R_NAME,R_COMMENT');
CALL set_table_property('REGION', 'dictionary_encoding_columns', 'R_NAME,R_COMMENT');
CALL set_table_property('REGION', 'time_to_live_in_seconds', '31536000');
COMMIT;

INSERT INTO public.customer SELECT * FROM public.odps_customer_10g ;
INSERT INTO public.lineitem SELECT * FROM public.odps_lineitem_10g ;
INSERT INTO public.nation SELECT * FROM public.odps_nation_10g ;
INSERT INTO public.orders SELECT * FROM public.odps_orders_10g ;
INSERT INTO public.part SELECT * FROM public.odps_part_10g ;
INSERT INTO public.partsupp SELECT * FROM public.odps_partsupp_10g ;
INSERT INTO public.region SELECT * FROM public.odps_region_10g ;
INSERT INTO public.supplier SELECT * FROM public.odps_supplier_10g ;

vacuum nation;
vacuum region;
vacuum supplier;
vacuum customer;
vacuum part;
vacuum partsupp;
vacuum orders;
vacuum lineitem;

analyze nation;
analyze region;
analyze lineitem;
analyze orders;
analyze customer;
analyze part;
analyze partsupp;
analyze supplier;
analyze lineitem (l_orderkey,l_partkey,l_suppkey);
analyze orders (o_custkey);
analyze partsupp(ps_partkey,ps_suppkey);

    Créer un entrepôt virtuel

    1. Connectez-vous à la console Hologres et accédez à la page de détails de l'instance cible.

    2. Dans le volet de navigation de gauche, cliquez sur Virtual Warehouse Management pour ouvrir l'onglet Virtual Warehouse Resource Management.

      La page affiche l'allocation des ressources réservées et élastiques de l'instance, et propose un bouton Add Virtual Warehouse pour créer un entrepôt virtuel.

    3. Cliquez sur Create Virtual Warehouse. Dans la boîte de dialogue, saisissez un Virtual Warehouse Name et sélectionnez une Virtual Warehouse Resource.

      Dans ce scénario, créez un entrepôt virtuel nommé read_warehouse_1.

      Pour cet exemple, sélectionnez 32 UC (32 cœurs, 128 Go de RAM, 2 nœuds) pour les Virtual Warehouse Resources, puis cliquez sur OK pour finaliser la création.

    4. Cliquez sur OK.

    5. Sur la page Virtual Warehouse Management, l'entrepôt virtuel est créé avec succès lorsque son statut dans la colonne Status est défini sur Running.

    Charger les données dans l'entrepôt virtuel

    Les groupes de tables sont des conteneurs de données dans Hologres. Pour interroger les données via un entrepôt virtuel, commencez par charger les groupes de tables requis dans celui-ci.

    1. Consultez les groupes de tables de la base de données actuelle.

      Exécutez l'instruction SQL suivante :

      SELECT tablegroup_name
FROM hologres.hg_table_group_properties
GROUP BY tablegroup_name;

      Exemple de résultat : la requête indique que le nom du groupe de tables est erp_database_tg_default.

      La base de données contient un seul groupe de tables.

    2. Chargez un groupe de tables pour l'entrepôt virtuel.

      Chargez erp_database_tg_default dans read_warehouse_1 afin qu'il puisse interroger les données :

      CALL hg_table_group_load_to_warehouse('erp_database.erp_database_tg_default', 'read_warehouse_1', 1);

    3. Vérifiez les groupes de tables chargés.

      SELECT * FROM hologres.hg_warehouse_table_groups;

      Exemple de résultat :image..png

      Le groupe de tables erp_database_tg_default est désormais chargé dans read_warehouse_1.

    Définir les permissions utilisateur

    Les utilisateurs ne peuvent pas accéder à un nouvel entrepôt virtuel sans permissions explicites. L'exemple suivant accorde à un utilisateur RAM nommé ram_test l'accès à read_warehouse_1.

    1. Consultez les permissions d'entrepôt virtuel d'un utilisateur.

      SELECT * FROM hologres.hg_warehouse_users;

    2. Consultez l'entrepôt virtuel par défaut d'un utilisateur.

      SELECT * FROM hologres.hg_user_default_warehouse;

    3. Ajoutez un utilisateur à l'instance.

      Sur la page Users de HoloWeb, ajoutez l'utilisateur RAM à l'instance Hologres. Gestion des utilisateurs.

      L'utilisateur RAM ajouté apparaît dans la liste User Account, avec le type de rôle par défaut défini sur Normal. Vous pouvez ajuster les permissions via l'option Modify Role Type dans la colonne Actions.

    4. Accordez à l'utilisateur ram_test des permissions de requête sur la base de données erp_database.

      Sur la page Database authorization de HoloWeb, accordez des permissions de requête sur la base de données à l'utilisateur ram_test. Accorder des permissions à un utilisateur RAM.

    5. Accordez à l'utilisateur ram_test l'accès à l'entrepôt virtuel read_warehouse_1.

      CALL hg_grant_warehouse_access_privilege ('read_warehouse_1', '"p4_2xxxxxxxxxxxxxxx"');

      Autoriser les utilisateurs à utiliser un entrepôt virtuel.

    6. Définissez read_warehouse_1 comme entrepôt virtuel par défaut pour l'utilisateur ram_test.

      Pour la séparation lecture/écriture, ram_test doit se connecter via read_warehouse_1 plutôt que via init_warehouse. Définissez l'entrepôt par défaut pour l'utilisateur ram_test :

      CALL hg_set_user_default_warehouse('"p4_2xxxxxxxxxxxxxxx"', 'read_warehouse_1');

    7. Vérifiez l'entrepôt virtuel utilisé par le compte actuel.

      Après vous être connecté en tant que ram_test, vérifiez l'entrepôt actif :

      SELECT current_warehouse();

    Basculez le trafic entre les entrepôts virtuels

    Si read_warehouse_1 tombe en panne, redirigez le trafic de ram_test vers init_warehouse.

    image..png

    Important

    • Les basculements de trafic prennent effet lors de la reconnexion. Assurez-vous que votre application dispose d'un mécanisme de reconnexion.

    • Utilisez le routage automatique lors de la connexion à Hologres. Ne spécifiez pas le nom d'un entrepôt virtuel dans la chaîne de connexion.

    1. Accordez à l'utilisateur ram_test l'accès à l'entrepôt virtuel init_warehouse.

      Si ram_test n'a pas déjà accès à init_warehouse, accordez à ram_test les permissions nécessaires afin que ram_test puisse utiliser les ressources de init_warehouse :

      CALL hg_grant_warehouse_access_privilege('init_warehouse', '"p4_2xxxxxxxxxxxxxxx"');

    2. Définissez init_warehouse comme entrepôt virtuel par défaut pour l'utilisateur ram_test.

      Définissez l'entrepôt par défaut de ram_test sur init_warehouse. Les nouvelles connexions utiliseront init_warehouse.

      CALL hg_set_user_default_warehouse('"p4_2xxxxxxxxxxxxxxx"', 'init_warehouse');

    3. Terminez les connexions n'utilisant pas l'entrepôt virtuel par défaut.

      SELECT hg_kill_non_default_warehouse_connections();

    4. Après la reconnexion, votre nouvelle session utilise l'entrepôt virtuel par défaut.