Realtime Compute for Apache Flink:Créer un entrepôt de données temps réel avec Hologres

Créer une instance RDS for MySQL et préparer les données

1. Créez une instance ApsaraDB RDS for MySQL. Pour plus d'informations, consultez Créer une instance ApsaraDB RDS for MySQL.

   L'instance ApsaraDB RDS for MySQL doit se trouver dans le même VPC que votre espace de travail Flink et votre instance Hologres.

2. Créez une base de données et un compte.

   Pour l'instance cible, créez une base de données nommée order_dw ainsi qu'un compte standard disposant des permissions de lecture et d'écriture sur cette base. Pour plus d'informations, consultez Créer une base de données et Créer un compte.

3. Préparez la source de données MySQL CDC.

   1. Sur la page de détails de l'instance, cliquez sur Log On to Database.

   2. Sur la page de connexion, saisissez le nom d'utilisateur et le mot de passe du compte de base de données créé, puis cliquez sur Log On.

   3. Une fois connecté, double-cliquez sur la base de données order_dw pour basculer dessus.

   4. Dans la console SQL, saisissez les instructions DDL suivantes pour créer les tables métier, ainsi que les instructions INSERT pour les alimenter.

      CREATE TABLE `orders` (
        order_id bigint not null primary key,
        user_id varchar(50) not null,
        shop_id bigint not null,
        product_id bigint not null,
        buy_fee numeric(20,2) not null,   
        create_time timestamp not null,
        update_time timestamp not null default now(),
        state int not null 
      );
      CREATE TABLE `orders_pay` (
        pay_id bigint not null primary key,
        order_id bigint not null,
        pay_platform int not null,
        create_time timestamp not null
      );
      CREATE TABLE `product_catalog` (
        product_id bigint not null primary key,
        catalog_name varchar(50) not null
      );
      -- Prepare data.
      INSERT INTO product_catalog VALUES(1, 'phone_aaa'),(2, 'phone_bbb'),(3, 'phone_ccc'),(4, 'phone_ddd'),(5, 'phone_eee');
      INSERT INTO orders VALUES
      (100001, 'user_001', 12345, 1, 5000.05, '2023-02-15 16:40:56', '2023-02-15 18:42:56', 1),
      (100002, 'user_002', 12346, 2, 4000.04, '2023-02-15 15:40:56', '2023-02-15 18:42:56', 1),
      (100003, 'user_003', 12347, 3, 3000.03, '2023-02-15 14:40:56', '2023-02-15 18:42:56', 1),
      (100004, 'user_001', 12347, 4, 2000.02, '2023-02-15 13:40:56', '2023-02-15 18:42:56', 1),
      (100005, 'user_002', 12348, 5, 1000.01, '2023-02-15 12:40:56', '2023-02-15 18:42:56', 1),
      (100006, 'user_001', 12348, 1, 1000.01, '2023-02-15 11:40:56', '2023-02-15 18:42:56', 1),
      (100007, 'user_003', 12347, 4, 2000.02, '2023-02-15 10:40:56', '2023-02-15 18:42:56', 1);
      INSERT INTO orders_pay VALUES
      (2001, 100001, 1, '2023-02-15 17:40:56'),
      (2002, 100002, 1, '2023-02-15 17:40:56'),
      (2003, 100003, 0, '2023-02-15 17:40:56'),
      (2004, 100004, 0, '2023-02-15 17:40:56'),
      (2005, 100005, 0, '2023-02-15 18:40:56'),
      (2006, 100006, 0, '2023-02-15 18:40:56'),
      (2007, 100007, 0, '2023-02-15 18:40:56');

4. Cliquez sur Execute, puis sur Direct Execution.

Créer une instance Hologres et des compute groups

1. Achetez une instance Hologres dédiée. Pour plus d'informations, consultez Acheter une instance Hologres.

   L'instance Hologres doit se trouver dans le même VPC que l'instance ApsaraDB RDS for MySQL. Pour bénéficier d'une forte isolation des ressources via la séparation lecture/écriture, cet exemple utilise le type d'instance Virtual Warehouse et définit la Reserved Compute Resource à 64, ce qui permet de créer des compute groups supplémentaires.

2. Après vous être connecté à l'instance, créez une base de données et attribuez les permissions.

   Créez une base de données nommée order_dw (avec le modèle de permissions simple activé) et accordez les privilèges administrateur à l'utilisateur. Pour plus de détails sur la gestion des bases de données et les autorisations, consultez Gérer les bases de données.

   Remarque

   • Si le compte n'apparaît pas dans la liste déroulante User, cela signifie qu'il n'a pas été ajouté à l'instance. Accédez à la page User Management et ajoutez l'utilisateur en tant que SuperUser.

   • À partir de Hologres V2.0, l'extension binary logging est activée par défaut. Aucune activation manuelle n'est nécessaire.

3. Créez un nouveau compute group.

   Différents compute groups permettent d'isoler les ressources. Utilisez le compute group initial init_warehouse pour les écritures de données et le compute group read_warehouse_1 pour répondre aux requêtes.

   Par défaut, toutes les ressources de calcul réservées sont allouées au compute group initial init_warehouse. Vous devez d'abord réduire ses ressources avant de pouvoir créer un nouveau compute group. Pour plus d'informations, consultez Créer une instance de compute group.

   1. Accédez à Security > Compute Group Management et confirmez le nom de l'instance.

   2. Dans la ligne correspondant au compute group init_warehouse, cliquez sur Modify Configuration dans la colonne Actions. Réduisez les ressources allouées, puis cliquez sur OK.

   3. Cliquez sur Create Compute Group, créez un nouveau compute group nommé read_warehouse_1, puis cliquez sur OK.

Créer un espace de travail Flink et des catalogs

1. Créez un espace de travail Flink. Pour plus d'informations, consultez Activer Realtime Compute for Apache Flink.

   L'espace de travail Flink doit se trouver dans le même VPC que les instances ApsaraDB RDS for MySQL et Hologres.

2. Connectez-vous à la console Realtime Compute for Apache Flink et cliquez sur Console dans la colonne Actions de votre espace de travail.

3. Créez un cluster de session pour fournir un environnement d'exécution permettant de créer des catalogs et d'exécuter des scripts. Pour plus d'informations, consultez Étape 1 : Créer un cluster de session.

4. Créez un catalog Hologres.

   Sur la page Development > Scripts, dans l'onglet Scripts, copiez le code suivant, remplacez les valeurs d'espace réservé, sélectionnez le code, puis cliquez sur Run. Le cluster de session créé sert alors d'environnement d'exécution.

   CREATE CATALOG dw WITH (
     'type' = 'hologres',
     'endpoint' = '< ENDPOINT>', 
     'username' = 'BASIC$flinktest',
     'password' = '${secret_values. holosecrect}',
     'dbname' = 'order_dw@init_warehouse', -- Specify the database name and connect to the init_warehouse compute group.
     'binlog' = 'true', -- You can set default WITH options for source, dimension, and result tables when creating the catalog. Tables created under this catalog inherit these defaults.
     'sdkMode' = 'jdbc', -- The jdbc mode is recommended.
     'cdcmode' = 'true',
     'connectionpoolname' = 'the_conn_pool',
     'ignoredelete' = 'true',  -- Required for wide-table merge to prevent retractions.
     'partial-insert. enabled' = 'true', -- Required for wide-table merge to enable partial column updates.
     'mutateType' = 'insertOrUpdate', -- Required for wide-table merge to enable partial column updates.
     'table_property. binlog. level' = 'replica', -- You can also pass persistent Hologres table properties when creating the catalog. Tables created later will have binary logging enabled by default.
     'table_property. binlog. ttl' = '259200'
   );

   Modifiez les paramètres suivants avec les informations réelles de votre service Hologres.

   Paramètre	Description	Notes
   endpoint	Endpoint de votre instance Hologres.	Sur la page de détails de l'instance Hologres, récupérez le nom de domaine correspondant au VPC spécifié. Pour plus d'informations sur les noms de domaine, consultez Endpoints.
   username	Choisissez l'une des options suivantes : Le nom d'utilisateur d'un compte personnalisé doit respecter le format BASIC$< user_name>. L'AccessKey ID de votre compte Alibaba Cloud ou de votre utilisateur RAM.	L'utilisateur configuré doit avoir accès à la base de données Hologres correspondante. Pour plus de détails, consultez Modèle de permissions Hologres et Gérer les utilisateurs. Cet exemple utilise un compte personnalisé nommé BASIC$flinktest et définit son mot de passe via une variable de projet nommée holosecrect, afin d'éviter les risques de sécurité liés au stockage des mots de passe en clair. Pour plus d'informations, consultez Variables de projet.
   password	Mot de passe du compte personnalisé. AccessKey secret de votre compte Alibaba Cloud ou de votre utilisateur RAM.

   Remarque

   Lors de la création d'un catalog, vous pouvez définir des options WITH par défaut pour les tables sources, de dimension et de résultat. Vous pouvez également configurer des propriétés par défaut pour les tables physiques Hologres, telles que les paramètres commençant par table_property. Pour plus d'informations, consultez Gérer les catalogs Hologres et Connecteur Hologres pour les entrepôts de données temps réel (paramètres WITH).

5. Créez un catalog MySQL.

   Copiez le code suivant dans l'onglet Scripts, modifiez les valeurs des paramètres, sélectionnez le code, puis cliquez sur Run. Le cluster de session créé sert alors d'environnement d'exécution.

   CREATE CATALOG mysqlcatalog WITH(
     'type' = 'mysql',
     'hostname' = '< hostname>',
     'port' = '< port>',
     'username' = '< username>',
     'password' = '${secret_values. mysql_pw}',
     'default-database' = 'order_dw'
   );

   Modifiez les paramètres suivants avec les informations réelles de votre service MySQL.

   Paramètre	Description
   hostname	Adresse IP ou nom d'hôte de votre base de données MySQL. Sur la page d'informations de base de la base de données, cliquez sur View Connection Details dans la zone Network Type pour obtenir l'endpoint interne.
   port	Numéro de port du service de base de données MySQL. La valeur par défaut est 3306.
   username	Nom d'utilisateur du service de base de données MySQL.
   password	Mot de passe du service de base de données MySQL. Cet exemple utilise une variable nommée mysql_pw pour le mot de passe afin d'éviter toute exposition en clair. Pour plus d'informations, consultez Gérer les variables.

Construire la couche ODS : Ingérer les données métier

Grâce à l'instruction CREATE DATABASE AS (CDAS) basée sur les catalogs, vous pouvez créer la couche ODS en une seule étape. Cette couche sert généralement de source d'événements pour les jobs de streaming plutôt que de cible directe pour des requêtes OLAP ou ponctuelles. L'activation du binary logging suffit donc pour cet usage. Le binary logging est une capacité centrale de Hologres. Le connecteur Hologres prend également en charge un mode complet + incrémental : il lit d'abord un snapshot complet, puis consomme les binary logs de manière incrémentale.

1. Créez le job de synchronisation CDAS ODS.

   1. Sur la page Development > ETL, créez un nouveau brouillon de flux SQL nommé ODS et copiez le code suivant dans l'éditeur SQL.

      -- The table_property. binlog. level parameter was set when creating the catalog, so all tables created by CDAS have binary logging enabled.
      CREATE DATABASE IF NOT EXISTS dw. order_dw   
      AS DATABASE mysqlcatalog. order_dw INCLUDING all tables -- You can select the upstream tables to ingest as needed.
      /*+ OPTIONS('server-id'='8001-8004') */;   -- Specify the server-id range for the mysql-cdc instance.

      Remarque

      • Par défaut, cet exemple synchronise les données vers le schéma Public de la base de données order_dw. Vous pouvez également synchroniser les données vers un schéma spécifique de la base de données Hologres cible. Pour plus d'informations, consultez Utiliser un catalog Hologres comme destination dans une instruction CREATE DATABASE AS.... Une fois un schéma spécifié, le format du nom de table change lors de l'utilisation du catalog. Pour plus de détails, consultez Utiliser un catalog Hologres.

      • Si le schéma d'une table source change, le schéma de la table résultante ne sera mis à jour qu'après une modification de données (suppression, insertion ou mise à jour) dans la table source.

   2. Dans le coin supérieur droit, cliquez sur Deploy pour déployer le job.

   3. Dans le volet de navigation de gauche, choisissez O&M > Deployments. Dans la ligne du job ODS que vous venez de déployer, cliquez sur Start dans la colonne Actions. Sélectionnez Initial Mode, puis cliquez sur Start.

2. Chargez les données dans le compute group.

   Un table group est un conteneur de données dans Hologres. Lorsque vous utilisez le compute group read_warehouse_1 pour interroger des données d'un table group dans la base de données order_dw, tel que order_dw_tg_default (pour créer un table group, consultez Table Group Management), le table group order_dw_tg_default est chargé pour le compute group read_warehouse_1. Cela vous permet d'utiliser le compute group init_warehouse pour écrire des données et le compute group read_warehouse_1 pour les requêtes de service.

   Sur la page de développement HoloWeb, cliquez sur SQL Editor. Confirmez le nom de l'instance et celui de la base de données, puis exécutez les commandes suivantes. Pour plus d'informations, consultez Créer une instance de compute group. Après le chargement, vous pouvez constater que read_warehouse_1 a bien chargé les données du table group order_dw_tg_default.

   -- List table groups in the current database.
   SELECT tablegroup_name FROM hologres. hg_table_group_properties GROUP BY tablegroup_name;
   -- Load a table group into a compute group.
   CALL hg_table_group_load_to_warehouse ('order_dw. order_dw_tg_default', 'read_warehouse_1', 1);
   -- Check the table groups loaded into the compute group.
   select * from hologres. hg_warehouse_table_groups;

3. Dans le coin supérieur droit, basculez le compute group vers read_warehouse_1. Les requêtes et analyses ultérieures utiliseront ce compute group.

   Dans le coin supérieur droit de la page HoloWeb, sélectionnez read_warehouse_1 dans la liste déroulante des compute groups.

4. Sur la page SQL Editor, exécutez les commandes suivantes pour visualiser les données synchronisées depuis MySQL vers les trois tables Hologres.

   -- Query data from the orders table.
   SELECT * FROM orders;
   -- Query data from the orders_pay table.
   SELECT * FROM orders_pay;
   -- Query data from the product_catalog table.
   SELECT * FROM product_catalog;

   Le résultat de la requête sur la table product_catalog contient deux colonnes, product_id (1 à 5) et catalog_name (phone_aaa, phone_bbb, phone_ccc, phone_ddd, phone_eee), pour un total de 5 enregistrements. Cela confirme que les données ont été correctement synchronisées vers Hologres.

Construire la couche DWD : Créer une table large temps réel

Cette étape exploite la capacité de mise à jour partielle des colonnes du connecteur Hologres. Vous pouvez exprimer ces mises à jour partielles via des instructions DML INSERT. Le job interroge plusieurs tables de dimension au moyen de requêtes ponctuelles haute performance, rendues possibles par le stockage ligne et le stockage hybride ligne-colonne de Hologres. Grâce à la forte isolation des ressources, les charges d'écriture, de lecture et d'analyse n'interfèrent pas entre elles.

1. Utilisez la fonctionnalité de catalog Flink pour créer la table large DWD dwd_orders dans Hologres.

   Sur la page Development > Scripts, copiez le code suivant dans l'onglet Scripts, sélectionnez le code, puis cliquez sur Run.

   -- Wide table columns must be nullable because different streams write to the same result table, and any column can be null.
   CREATE TABLE dw. order_dw. dwd_orders (
     order_id bigint not null,
     order_user_id string,
     order_shop_id bigint,
     order_product_id bigint,
     order_product_catalog_name string,
     order_fee numeric(20,2),
     order_create_time timestamp,
     order_update_time timestamp,
     order_state int,
     pay_id bigint,
     pay_platform int comment 'platform 0: phone, 1: pc', 
     pay_create_time timestamp,
     PRIMARY KEY(order_id) NOT ENFORCED
   );
   -- You can modify Hologres physical table properties through the catalog.
   ALTER TABLE dw. order_dw. dwd_orders SET (
     'table_property. binlog. ttl' = '604800' -- Change the binary log TTL to one week.
   );

2. Consommez en temps réel les modifications du binary logging des tables ODS orders et orders_pay.

   Sur la page Development > ETL, créez un nouveau brouillon de flux SQL nommé DWD. Copiez le code suivant dans l'éditeur SQL, puis Deploy et Start le job. Ce job SQL joint les tables orders et product_catalog à l'aide d'une jointure temporelle et écrit le résultat dans la table dwd_orders, enrichissant ainsi les données en temps réel.

   BEGIN STATEMENT SET;
   INSERT INTO dw. order_dw. dwd_orders 
    (
      order_id,
      order_user_id,
      order_shop_id,
      order_product_id,
      order_fee,
      order_create_time,
      order_update_time,
      order_state,
      order_product_catalog_name
    ) SELECT o.*, dim. catalog_name 
      FROM dw. order_dw. orders as o
      LEFT JOIN dw. order_dw. product_catalog FOR SYSTEM_TIME AS OF proctime() AS dim
      ON o. product_id = dim. product_id;
   INSERT INTO dw. order_dw. dwd_orders 
     (pay_id, order_id, pay_platform, pay_create_time)
      SELECT * FROM dw. order_dw. orders_pay;
   END;

3. Visualisez les données de la table large dwd_orders.

   Connectez-vous à l'instance Hologres sur la page de développement HoloWeb, connectez-vous à la base de données cible, puis exécutez la commande suivante dans l'éditeur SQL.

   SELECT * FROM dwd_orders;

   Après une exécution réussie, le résultat de la requête renvoie les données de la table large dwd_orders, incluant des champs tels que order_id, order_user_id, order_shop_id, order_product_id, order_product_catalog_name, order_fee, order_create_time et order_update_time.

Construire la couche DWS : Calculer les métriques temps réel

1. Utilisez la fonctionnalité de catalog Flink pour créer les tables d'agrégation DWS dws_users et dws_shops dans Hologres.

   Sur la page Development > Scripts, copiez le code suivant dans l'onglet Scripts, sélectionnez le code, puis cliquez sur Run.

   -- User-dimension aggregate table.
   CREATE TABLE dw. order_dw. dws_users (
     user_id string not null,
     ds string not null,
     paied_buy_fee_sum numeric(20,2) not null comment 'Total amount of payments completed on the day',
     primary key(user_id, ds) NOT ENFORCED
   );
   -- Shop-dimension aggregate table.
   CREATE TABLE dw. order_dw. dws_shops (
     shop_id bigint not null,
     ds string not null,
     paied_buy_fee_sum numeric(20,2) not null comment 'Total amount of payments completed on the day',
     primary key(shop_id, ds) NOT ENFORCED
   );

2. Consommez la table large DWD dw. order_dw. dwd_orders en temps réel, effectuez les agrégations dans Flink, puis écrivez les résultats finaux dans les tables DWS de Hologres.

   Sur la page Development > ETL, créez un nouveau brouillon de flux SQL nommé DWS. Copiez le code suivant dans l'éditeur SQL, puis Deploy et Start le job.

   BEGIN STATEMENT SET;
   INSERT INTO dw. order_dw. dws_users
     SELECT 
       order_user_id,
       DATE_FORMAT (pay_create_time, 'yyyyMMdd') as ds,
       SUM (order_fee)
       FROM dw. order_dw. dwd_orders c
       WHERE pay_id IS NOT NULL AND order_fee IS NOT NULL -- Both order and payment stream data have been written to the wide table.
       GROUP BY order_user_id, DATE_FORMAT (pay_create_time, 'yyyyMMdd');
   INSERT INTO dw. order_dw. dws_shops
     SELECT 
       order_shop_id,
       DATE_FORMAT (pay_create_time, 'yyyyMMdd') as ds,
       SUM (order_fee)
      FROM dw. order_dw. dwd_orders c
      WHERE pay_id IS NOT NULL AND order_fee IS NOT NULL -- Both order and payment stream data have been written to the wide table.
      GROUP BY order_shop_id, DATE_FORMAT (pay_create_time, 'yyyyMMdd');
   END;

3. Consultez les résultats agrégés dans la couche DWS. Ces résultats sont mis à jour en temps réel à mesure que les données en amont changent.

   1. Visualisez les données dans la console Hologres avant la modification.

      Table dws_users

      SELECT * FROM dws_users;

      Après l'exécution de la requête, le résultat renvoie les données de la table dws_users, qui comprend trois colonnes : user_id, ds et paied_buy_fee_sum. Dans l'exemple de résultat, la colonne user_id contient les valeurs user_001, user_002 et user_003 ; la colonne ds contient la valeur 20230215 ; et la colonne paied_buy_fee_sum contient respectivement les valeurs 8000.08, 5000.05 et 5000.05. La colonne user_id identifie de manière unique chaque utilisateur.

      Table dws_shops

      SELECT * FROM dws_shops;

      Le résultat de la requête montre que la table dws_shops contient trois colonnes : shop_id (ID de la boutique), ds (partition de date) et paied_buy_fee_sum (montant du paiement). Quatre lignes de données d'exemple sont renvoyées, confirmant que la table de la couche DWS a été construite avec succès.

   2. Dans la console RDS, insérez un nouvel enregistrement dans chacune des tables orders et orders_pay de la base de données order_dw.

      INSERT INTO orders VALUES
      (100008, 'user_003', 12345, 5, 6000.02, '2023-02-15 09:40:56', '2023-02-15 18:42:56', 1);
      INSERT INTO orders_pay VALUES
      (2008, 100008, 1, '2023-02-15 19:40:56');

   3. Visualisez les données mises à jour dans la console Hologres.

      Table dwd_orders

      SELECT * FROM dwd_orders;

      Après l'exécution de la requête, huit enregistrements de commande sont renvoyés depuis la table dwd_orders, incluant des champs tels que order_id, order_user_id, order_shop_id, order_product_id, order_product_catalog_name, order_fee, order_create_time et order_update_time. Le huitième enregistrement (order_id=100008, user_003, phone_eee, 6000.02) correspond aux données nouvellement écrites.

      Table dws_users

      SELECT * FROM dws_users;

      La requête renvoie trois lignes composées de trois colonnes : user_id, ds et paied_buy_fee_sum : user_001 / 20230215 / 8000.08, user_002 / 20230215 / 5000.05 et user_003 / 20230215 / 11000.07. Le montant total de paiement le plus élevé concerne l'utilisateur user_003 (11000.07).

      Table dws_shops

      SELECT * FROM dws_shops;

      Une fois la requête exécutée, le résultat contient trois colonnes, shop_id, ds et paied_buy_fee_sum, avec quatre lignes de données affichant les montants (11000.07, 4000.04, 7000.07 et 2000.02) pour les boutiques 12345, 12346, 12347 et 12348 à la date du 20230215. Les colonnes shop_id et paied_buy_fee_sum constituent les métriques clés.

Profiler les données

Puisque le binary logging est activé, vous pouvez inspecter directement les modifications de données. Si vous devez effectuer une exploration ad hoc des données métier sur des résultats intermédiaires ou vérifier l'exactitude du calcul final, chaque couche de cette solution est persistée, ce qui facilite l'examen du processus intermédiaire.

SELECT *
FROM dw. order_dw. dwd_orders /*+ OPTIONS('binlog'='false') */ 
WHERE order_user_id = 'user_001' and order_create_time > '2023-02-15 12:00:00'; -- Batch mode supports filter pushdown to improve batch job execution efficiency.

Requête ponctuelle

Interrogez les tables de métriques agrégées de la couche DWS par clé primaire, avec une capacité de plusieurs millions de RPS.

Sur la page de développement HoloWeb, exécutez le code SQL suivant pour interroger le montant de consommation d'un utilisateur spécifique à une date donnée.

-- holo sql
SELECT * FROM dws_users WHERE user_id ='user_001' AND ds = '20230215';

Le résultat de la requête renvoie trois colonnes : user_id, ds et paied_buy_fee_sum (montant de consommation). Le montant de consommation pour user_001 à la date du 20230215 est de 8000.08.

Requête OLAP

Exécutez des requêtes OLAP sur la table large de la couche DWD.

Sur la page de développement HoloWeb, exécutez le code SQL suivant pour interroger les détails des commandes d'un client spécifique sur une plateforme de paiement donnée en février 2023.

-- holo sql
SELECT * FROM dwd_orders
WHERE order_create_time >= '2023-02-01 00:00:00'  and order_create_time < '2023-03-01 00:00:00'
AND order_user_id = 'user_001'
AND pay_platform = 0
ORDER BY order_create_time LIMIT 100;

Le résultat de la requête renvoie deux enregistrements de commande avec des champs tels que order_id, order_user_id, order_shop_id, order_product_id, order_fee, order_create_time et order_update_time. Les ID de commande de l'exemple sont 100006 et 100004.

Rapports temps réel

Générez des rapports temps réel à partir des données de la table large de la couche DWD. Le stockage hybride ligne-colonne et les tables orientées colonne de Hologres offrent d'excellentes capacités de requête OLAP, garantissant des temps de réponse de l'ordre de la seconde.

Sur la page de développement HoloWeb, exécutez le code SQL suivant pour interroger le nombre total de commandes et le montant total des commandes pour chaque catégorie de produits en février 2023.

-- holo sql
SELECT
  TO_CHAR(order_create_time, 'YYYYMMDD') AS order_create_date,
  order_product_catalog_name,
  COUNT(*),
  SUM(order_fee)
FROM
  dwd_orders
WHERE
  order_create_time >= '2023-02-01 00:00:00'  and order_create_time < '2023-03-01 00:00:00'
GROUP BY
  order_create_date, order_product_catalog_name
ORDER BY
  order_create_date, order_product_catalog_name;

Après l'exécution de l'instruction SQL, l'onglet Result affiche un tableau composé de quatre colonnes : order_create_date, order_product_catalog_name, count et sum. Par exemple, les résultats pour la date du 20230215 indiquent que la catégorie phone_aaa comptait 2 commandes pour un total de 6000.06, la catégorie phone_bbb comptait 1 commande pour 4000.04, et ainsi de suite pour les cinq catégories.