Présentation

Bienvenue dans le guide Quickstart Powered by Tasty Bytes Débuter avec Snowflake sur le traitement des données semi-structurées !

Dans ce guide Quickstart, vous allez apprendre à traiter des données semi-structurées dans Snowflake. Vous allez notamment découvrir le type de données VARIANT, comment traiter des données semi-structurées via la notation par points et la fonction d'aplatissement avec vue latérale, comment créer des vues et comment utiliser des graphiques Snowsight.

Pour plus d'informations au sujet des données semi-structurées dans Snowflake, consultez l'article de documentation intitulé Données semi-structurées.

Conditions préalables

Vous allez apprendre :

Vous allez créer :

Présentation

Dans ce guide Quickstart, vous allez suivre une histoire de Tasty Bytes via une feuille de calcul SQL Snowsight. Cette page, qui fait office de guide étape par étape, comprend également des commentaires, des images et des liens vers de la documentation.

Cette section vous explique comment vous connecter à Snowflake, comment créer une nouvelle feuille de calcul et la renommer, mais aussi comment copier le fichier SQL que nous allons utiliser dans ce guide Quickstart depuis GitHub et le coller.

Étape 1 – Accéder à Snowflake via une URL

Étape 2 – Se connecter à Snowflake

Étape 3 – Accéder aux feuilles de calcul

Étape 4 – Créer une feuille de calcul

Étape 5 – Renommer une feuille de calcul

Étape 6 – Accéder au fichier SQL de ce guide Quickstart dans GitHub

Étape 7 – Copier le fichier de configuration SQL depuis GitHub

Étape 8 – Coller le fichier de configuration SQL depuis GitHub dans une feuille de calcul Snowflake

Étape 9 – Cliquer sur Next (Suivant) –>

Présentation

En tant que data engineers de Tasty Bytes, il nous a été demandé d'établir le profil de nos données de menu, qui doit inclure une colonne pour les données semi-structurées. Depuis cette table de menu, nous devons créer une vue de couche d'analyse qui affiche les données relatives aux ingrédients et aux restrictions alimentaires pour nos utilisateurs finaux.

Étape 1 – Définir le contexte et interroger la table

Commençons par exécuter en même temps les trois premières requêtes qui permettront de:

USE ROLE tasty_data_engineer; 
USE WAREHOUSE tasty_de_wh;

SELECT TOP 10
    m.truck_brand_name, 
    m.menu_type, m.menu_item_name, 
    m.menu_item_health_metrics_obj 
FROM frostbyte_tasty_bytes.raw_pos.menu m;

Les résultats renvoyés nous montrent que menu_item_health_metrics_obj doit correspondre aux données semi-structurées censées contenir les indicateurs que nous devons fournir en aval.

Si vous cliquez sur l'une des cellules de cette colonne, Snowsight développera automatiquement le volet des statistiques pour vous en donner un meilleur aperçu.

Étape 2 – Explorer la colonne de données semi-structurées

Pour examiner de plus près comment cette colonne est définie dans Snowflake, exécutez la requête suivante, qui nous permet d'exploiter la commande SHOW COLUMNS pour explorer les types de données figurant dans notre table menu.

SHOW COLUMNS IN frostbyte_tasty_bytes.raw_pos.menu;

Dans notre jeu de résultats, nous constatons que menu_item_health_metrics_obj est un type de données VARIANT.

Étape 3 – Parcourir des données semi-structurées à l'aide de la notation par points

Dans notre colonne menu_item_health_metrics_obj, nous avons vu que menu_item_id était inclus avec les données relatives aux ingrédients et aux restrictions alimentaires les plus imbriquées auxquelles nous devons accéder.

Exécutez la requête suivante, qui nous permet de commencer à utiliser la notation par points pour parcourir nos données semi-structurées.

SELECT 
    m.menu_item_health_metrics_obj:menu_item_id AS menu_item_id,
    m.menu_item_health_metrics_obj:menu_item_health_metrics AS menu_item_health_metrics
FROM frostbyte_tasty_bytes.raw_pos.menu m;

Grâce à la notation par points, nous avons pu extraire complètement menu_item_id, mais il semble qu'il reste encore des objets semi-structurés supplémentaires dans la sortie de la colonne menu_item_health_metrics.

Cliquons de nouveau sur l'une des cellules de cette colonne pour en examiner le contenu plus en détail.

Nous progressons ! Dans la prochaine section, voyons comment nous pouvons aller plus loin dans le traitement de menu_item_health_metrics en utilisant d'autres fonctions Snowflake.

Étape 4 – Cliquer sur Next (Suivant) –>

Présentation

Après avoir vu comment nous pouvons facilement interroger des données semi-structurées qui figurent dans une colonne VARIANT à l'aide de la notation par points, en tant que data engineer chez Tasty Bytes, vous êtes bien parti pour fournir aux parties prenantes internes les données qu'elles vous ont demandées.

Dans cette section, nous allons procéder à un traitement plus poussé des données semi-structurées afin de répondre à certains besoins.

Étape 1 – Découvrir la fonction d'aplatissement avec vue latérale

Cette fonction permet d'extraire de notre colonne menu_item_health_metrics_obj davantage de données demandées par nos utilisateurs en aval. Exécutez la requête suivante, qui utilise la fonctionnalité de notation par points dont nous venons de parler, avec les fonctions d'aplatissement (FLATTEN) et de jointure latérale (LATERAL JOIN) de Snowflake pour nous fournir le premier ARRAY ingredient qu'on nous a demandé.

SELECT 
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

Étape 2 – Explorer une fonction de tableau (ARRAY)

Avant que nous procédions à l'extraction des données requises relatives aux restrictions alimentaires, exécutez la requête suivante, à l'aide de la fonction de tableau Snowflake ARRAY_CONTAINS, qui vous permettra d'explorer la colonne ingredients pour tout menu_item_name qui contient de la laitue.

SELECT 
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj
WHERE ARRAY_CONTAINS('Lettuce'::VARIANT, obj.value:"ingredients"::VARIANT);

Les résultats renvoyés nous montrent que plusieurs de nos éléments de menu incluent de la laitue. Ce type d'analyse serait très utile aux Procurement Managers de notre chaîne d'approvisionnement en cas de rappels d'aliments dans les villes et pays dans lesquels nous intervenons.

Étape 3 – Structurer des données semi-structurées à grande échelle

Après avoir vu le type de valeur ajoutée que nous pouvons déjà apporter à notre organisation, nous pouvons maintenant exécuter la dernière requête de cette section.

Cette requête utilisera la notation par points, ainsi que notre double fonction de table LATERAL JOIN et FLATTEN, pour fournir le jeu de résultats que l'on nous a initialement demandé de générer.

SELECT 
    m.menu_item_health_metrics_obj:menu_item_id::integer AS menu_item_id,
    m.menu_item_name,
    obj.value:"ingredients"::VARIANT AS ingredients,
    obj.value:"is_healthy_flag"::VARCHAR(1) AS is_healthy_flag,
    obj.value:"is_gluten_free_flag"::VARCHAR(1) AS is_gluten_free_flag,
    obj.value:"is_dairy_free_flag"::VARCHAR(1) AS is_dairy_free_flag,
    obj.value:"is_nut_free_flag"::VARCHAR(1) AS is_nut_free_flag
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

Parfait ! Ces résultats semblent être conformes aux besoins exacts de nos parties prenantes. Dans la section suivante, nous allons voir comment nous pouvons mettre à profit ces résultats dans notre couche d'analyse, où ils peuvent être consultés par nos parties prenantes.

Étape 4 – Cliquer sur Next (Suivant) –>

Présentation

Dans la section précédente, nous avons créé une requête qui fournit les résultats exacts requis par nos utilisateurs finaux à l'aide d'une suite de fonctionnalités de données semi-structurées Snowflake. Nous allons poursuivre le processus qui consiste à mettre à profit cette requête qui se trouve dans notre couche brute vers la couche harmonisée, puis dans la couche d'analyse, d'où nos utilisateurs finaux sont autorisés à lire des données.

Remarque : pour les habitués des modèles de données Bronze, Silver et Gold, ces derniers correspondent, respectivement, aux couches brute, harmonisée et d'analyse.

Étape 1 – Créer une vue harmonisée à l'aide de la requête SQL d'aplatissement des données semi-structurées

En reprenant la requête exacte de la fin de la section précédente, exécutez la requête suivante, qui contient cette requête SQL ainsi que toutes les autres colonnes de la table menu déjà structurées.

Dans cette requête, nous utilisons la commande CREATE VIEW dans notre schéma harmonisé pour encapsuler la logique de traitement des données semi-structurées et d'autres colonnes sous forme de table.

CREATE OR REPLACE VIEW frostbyte_tasty_bytes.harmonized.menu_v
    AS
SELECT 
    m.menu_id,
    m.menu_type_id,
    m.menu_type,
    m.truck_brand_name,
    m.menu_item_health_metrics_obj:menu_item_id::integer AS menu_item_id,
    m.menu_item_name,
    m.item_category,
    m.item_subcategory,
    m.cost_of_goods_usd,
    m.sale_price_usd,
    obj.value:"ingredients"::VARIANT AS ingredients,
    obj.value:"is_healthy_flag"::VARCHAR(1) AS is_healthy_flag,
    obj.value:"is_gluten_free_flag"::VARCHAR(1) AS is_gluten_free_flag,
    obj.value:"is_dairy_free_flag"::VARCHAR(1) AS is_dairy_free_flag,
    obj.value:"is_nut_free_flag"::VARCHAR(1) AS is_nut_free_flag
FROM frostbyte_tasty_bytes.raw_pos.menu m,
    LATERAL FLATTEN (input => m.menu_item_health_metrics_obj:menu_item_health_metrics) obj;

La vue harmonized.menu_v étant créée, nous pourrions désormais l'interroger directement sans avoir à exploiter la requête SQL plus complexe que nous avons utilisée pour la créer. Toutefois, étant donné que la couche d'analyse est celle où nos parties prenantes consultent des données, passons à l'étape suivante pour insérer la requête dans cette couche.

Étape 2 – Utiliser la requête de la couche harmonisée dans la couche d'analyse en toute simplicité

À partir de la vue harmonized.menu_v, exécutez la requête suivante pour créer notre vue analytics.menu_v, qui commencera immédiatement à créer de la valeur en aval.

Dans cette requête, nous voyons de nouvelles fonctions dont nous n'avons pas encore parlé. Nous ajoutons tout d'abord une fonction COMMENT, visible dans les commandes de SHOW VIEWS ou dans l'interface Snowsight, pour documenter ce qu'un utilisateur peut voir lorsqu'il interroge cette vue.

Nous utilisons également les paramètres SELECT * EXCLUDE et RENAME, qui peuvent faciliter la vie des développeurs SQL en simplifiant la définition de la requête ou de la vue.

Étape 3 – Cliquer sur Next (Suivant) –>

Présentation

Notre vue de menu étant disponible dans notre couche d'analyse, interrogeons-la en exécutant plusieurs requêtes qui montreront à nos utilisateurs finaux comment Snowflake crée une expérience de requête relationnelle à partir de données semi-structurées sans avoir à en faire des copies supplémentaires ou à les traiter de manière complexe.

Étape 1 – Analyser des tableaux (ARRAY)

La requête de la section précédente a renvoyé la colonne ingredients, mais celle-ci est désormais disponible sans aucune exigence en matière de notation par points dans notre vue analytics.menu_v.

Avec cette vue, vous devez désormais exécuter la requête suivante, qui exploite deux autres fonctions de tableau Snowflake, ARRAY_INTERSECTION et ARRAYS_OVERLAP, pour voir quels éléments de menu hors boissons se chevauchent pour chacun des menus de nos marques de food trucks.

SELECT 
    m1.menu_type,
    m1.menu_item_name,
    m2.menu_type AS overlap_menu_type,
    m2.menu_item_name AS overlap_menu_item_name,
    ARRAY_INTERSECTION(m1.ingredients, m2.ingredients) AS overlapping_ingredients
FROM frostbyte_tasty_bytes.analytics.menu_v m1
JOIN frostbyte_tasty_bytes.analytics.menu_v m2
    ON m1.menu_item_id <> m2.menu_item_id -- avoid joining the same menu item to itself
    AND m1.menu_type <> m2.menu_type 
WHERE 1=1
    AND m1.item_category <> 'Beverage' -- remove beverages
    AND m2.item_category <> 'Beverage' -- remove beverages
    AND ARRAYS_OVERLAP(m1.ingredients, m2.ingredients) -- evaluates to TRUE if one ingredient is in both arrays
ORDER BY m1.menu_type;

De nouveau, en utilisant exactement la vue que nous avons créée, ce type de requête pourrait apporter une véritable valeur commerciale aux opérateurs de nos food trucks, en les aidant à prévoir et commander les ingrédients dont ils ont besoin chaque semaine.

Étape 2 – Fournir des indicateurs aux dirigeants

Essayons maintenant d'aider les dirigeants de Tasty Bytes à prendre des décisions au sujet des menus basées sur les données, en leur fournissant des indicateurs globaux relatifs aux restrictions alimentaires que nous gérons actuellement dans l'ensemble de nos marques.

Exécutez la requête suivante, qui utilise les fonctions COUNT, SUM et CASE (conditionnelle) pour agréger les indicateurs requis depuis notre vue analytics.menu_v.

SELECT
    COUNT(DISTINCT menu_item_id) AS total_menu_items,
    SUM(CASE WHEN is_healthy_flag = 'Y' THEN 1 ELSE 0 END) AS healthy_item_count,
    SUM(CASE WHEN is_gluten_free_flag = 'Y' THEN 1 ELSE 0 END) AS gluten_free_item_count,
    SUM(CASE WHEN is_dairy_free_flag = 'Y' THEN 1 ELSE 0 END) AS dairy_free_item_count,
    SUM(CASE WHEN is_nut_free_flag = 'Y' THEN 1 ELSE 0 END) AS nut_free_item_count
FROM frostbyte_tasty_bytes.analytics.menu_v m;

Les résultats que nous venons de recevoir prouvent que nous sommes parvenus à passer d'une table brute contenant des données semi-structurées à une seule ligne agrégée, à laquelle tous les membres de notre organisation peuvent accéder afin d'aider Tasty Bytes à adopter un modèle davantage axé sur les données.

Étape 3 – Convertir des résultats en graphiques

Certains des dirigeants de Tasty Bytes préfèrent des représentations visuelles des données. Voyons à quel point il est facile de convertir des résultats renvoyés sous forme de tableau en graphiques visuels faciles à assimiler dans Snowsight.

Avec la requête SQL que nous avons précédemment utilisée, exécutez la requête suivante, qui ajoute des filtres sur trois noms de nos marques de camionnettes.

SELECT
    m.brand_name,
    SUM(CASE WHEN is_gluten_free_flag = 'Y' THEN 1 ELSE 0 END) AS gluten_free_item_count,
    SUM(CASE WHEN is_dairy_free_flag = 'Y' THEN 1 ELSE 0 END) AS dairy_free_item_count,
    SUM(CASE WHEN is_nut_free_flag = 'Y' THEN 1 ELSE 0 END) AS nut_free_item_count
FROM frostbyte_tasty_bytes.analytics.menu_v m
WHERE m.brand_name IN  ('Plant Palace', 'Peking Truck','Revenge of the Curds')
GROUP BY m.brand_name;

Par défaut, Snowsight renvoie les résultats des requêtes sous forme de tableau. Cependant, Snowsight contient une fonctionnalité efficace dont nous n'avons pas encore parlé, l'utilisation des graphiques.

Suivez les flèches figurant sur la capture d'écran ci-dessous pour créer un graphique à barres qui compare les éléments de menu de ces différentes marques de food truck concernant certaines restrictions alimentaires.

Pour terminer ce guide Quickstart, nous devons préciser à quel point il serait facile pour un dirigeant de Tasty Bytes de réaliser lui-même ce type d'analyse sans avoir à connaître la logique de traitement des données semi-structurées que nous avons encapsulée dans les vues que nous avons créées. Nous sommes ainsi sûrs de participer au développement de la démocratisation des données au sein de l'organisation Tasty Bytes.

Étape 4 – Cliquer sur Next (Suivant) –>

Conclusion

Beau travail ! Vous avez terminé le guide Quickstart Tasty Bytes Débuter avec Snowflake sur les données semi-structurées.

Vous avez :

Si vous voulez recommencer ce guide Quickstart, utilisez les scripts de réinitialisation en bas de votre feuille de calcul associée.

Prochaines étapes

Pour continuer à découvrir le Data Cloud Snowflake, cliquez sur le lien ci-dessous pour voir tous les autres guides Quickstart Powered by Tasty Bytes à votre disposition.