Précédent

Suivant

Exercice - Introduire des variables à l’aide de l’instruction let

Effectué

Nous avons utilisé un jeu de données météorologique pour agréger et visualiser des données. Ici, vous allez apprendre à utiliser des instructions let pour introduire des variables et organiser des requêtes complexes.

Les instructions let sont utiles pour décomposer une expression complexe en plusieurs parties, définir des constantes en dehors du corps de la requête pour la lisibilité ou définir une variable une fois et l’utiliser plusieurs fois dans une requête. Vous pouvez utiliser des instructions let pour créer des requêtes complexes bien organisées. Vous pouvez utiliser plusieurs instructions let. Chaque instruction doit être suivie d’un point-virgule (;).

Vous pouvez utiliser des instructions let dans différents types de situations. Au niveau le plus simple, vous pouvez définir des valeurs scalaires qui seront ultérieurement référencées dans une requête, comme un entier, une chaîne, une date/heure ou toute autre valeur. Vous pouvez créer une vue filtrée tabulaire d’une table qui sera utilisée comme entrée tabulaire pour la requête. Vous pouvez également créer une fonction à l’aide d’une instruction let.

Définir un scalaire avec une instruction let

Rappelez-vous les requêtes précédentes filtrées sur des emplacements ou des dommages minimum. Nous allons définir ces valeurs de limite à l’aide d’une instruction let au début de la requête.

La requête suivante utilise deux instructions let pour définir des valeurs scalaires qui seront ensuite utilisées comme paramètres d’entrée dans la requête. La première valeur définie est un nombre et la seconde est une chaîne. Les instructions let se terminent par un point-virgule.

Notez les parties commentées de la requête qui commencent par des doubles barres obliques (//). Les doubles barres obliques indiquent le début d’un commentaire jusqu’à la fin de la ligne. Il s’agit de commentaires ignorés lors de l’exécution des requêtes.

1. Exécutez la requête suivante :

   Exécuter la requête

   let MinDamage = 1; // int
   let EventLocation = "ARIZONA"; // string
   StormEvents
   | where State == EventLocation
   | where DamageCrops + DamageProperty >= MinDamage
   | summarize Damage=round(avg(DamageProperty + DamageCrops)) by EventType
   | sort by Damage
   

   Vous devez obtenir des résultats qui ressemblent à l’image suivante :

   

2. Essayez de modifier le nom de l’état ou les nombres de dommages minimum et réexécutez la requête. Comment les résultats changent-ils ?

Convertir un résultat tabulaire en valeur scalaire à l’aide de toscalar dans une instruction let

Examinons ensuite un nombre du type d’événement le plus fréquent en fonction du temps. Vous devez tout d’abord déterminer le type d’événement le plus fréquent. Vous utiliserez ensuite cette valeur dans une requête. Utilisez la table StormEvents pour rechercher le premier EventType en comptant le nombre d’événements dans chaque type. Utilisez l’opérateur project pour retourner uniquement la colonne EventType.

Avant de commencer à construire l’instruction let, exécutez la requête pour savoir à quoi correspond réellement cet événement. Cela vous permet de vérifier que votre requête produit les résultats attendus.

Exécuter la requête

StormEvents
| summarize count() by EventType
| top 1 by count_
| project EventType

Vous devez obtenir des résultats qui ressemblent à l’image suivante :

Vous remarquerez que la requête a produit un résultat tabulaire avec une colonne et une ligne. Toutefois, vous souhaitez convertir cette valeur en valeur scalaire à utiliser comme valeur de filtre dans votre requête principale. Définissez tout d’abord le nom de la variable que nous voulons introduire en tant que MostFrequentEventType. Vous souhaitez ensuite convertir le résultat tabulaire en valeur scalaire en plaçant la requête entière dans la fonction toscalar().

Les étapes précédentes sont résumées dans l’instruction let suivante :

let MostFrequentEventType = toscalar(
    StormEvents
    | summarize count() by EventType
    | top 1 by count_
    | project EventType);

Notez que cette instruction n’est pas une requête valide, car une requête valide doit contenir au moins une instruction qui n’est pas une instruction let. Vous pouvez toutefois utiliser cette valeur scalaire stockée dans une requête. Rappelez-vous que vous souhaitez examiner un nombre de temps d’événement le plus fréquent en fonction du temps. Vous allez filtrer sur MostFrequentEventType, puis résumer le nombre par un temps donné.

Dans ce cas, examinons les résultats par mois. Vous allez utiliser la fonction startofmonth(), qui retourne une date/heure représentant le début du mois pour la valeur de date donnée. Dans cette requête, vous allez utiliser la colonne StartTime comme entrée pour la fonction startofmonth().

Enfin, affichez les résultats sous forme de graphique en colonnes pour obtenir un histogramme du nombre de type d’événement le plus fréquent par mois.

1. Exécutez la requête suivante :

   Exécuter la requête

   let MostFrequentEventType = toscalar(
       StormEvents
       | summarize count() by EventType
       | top 1 by count_
       | project EventType);
   StormEvents
   | where EventType == MostFrequentEventType
   | summarize count() by startofmonth(StartTime)
   | render columnchart
   

   Vous devez obtenir des résultats qui ressemblent à l’image suivante :

   

2. Essayez de modifier la requête pour afficher un histogramme du type d’événement le moins fréquent par mois et réexécutez la requête.

Construire une instruction let avec une sortie tabulaire

Les exemples précédents ont créé une valeur scalaire stockée à utiliser comme paramètre d’entrée dans une requête. Toutefois, il est également possible d’utiliser une instruction let pour créer des données tabulaires qui sont ensuite utilisées comme entrée dans une requête.

1. Filtrez la table StormEvents sur les événements qui ont indirectement ou directement provoqué des décès. Retournez ensuite un sous-ensemble des colonnes à l’aide de l’opérateur project. Cette instruction donne une sortie tabulaire appelée KillerStorms. Utilisez cette instruction let comme entrée de début pour votre requête.

   let KillerStorms =
       StormEvents
       | where DeathsDirect + DeathsIndirect > 0
       | project State, EventType, Deaths=DeathsDirect + DeathsIndirect;
   

2. Vous pouvez ensuite utiliser certaines des fonctions d’agrégation que vous avez apprises dans les leçons précédentes. Exécutez la requête suivante :

   Exécuter la requête

   let KillerStorms =
       StormEvents
       | where DeathsDirect + DeathsIndirect > 0
       | project State, EventType, Deaths=DeathsDirect + DeathsIndirect;
   KillerStorms
   | summarize DistinctKillerEventTypes=dcount(EventType), TotalDeaths=sum(Deaths) by State
   | sort by TotalDeaths
   

   Vous devez obtenir des résultats qui ressemblent à l’image suivante :

   

3. Afficher les résultats. Tous les événements sont-ils résumés dans la colonne DistinctKillerEventTypes appelée « killer storms » ?

Créer une fonction définie par l’utilisateur avec l’instruction let

Vous pouvez également utiliser des instructions let pour définir des fonctions définies par l’utilisateur, qui sont des sous-requêtes réutilisables. Supposons que vous souhaitiez déterminer le pourcentage de chaque type d’événement ayant causé des dommages. Vous allez créer une fonction définie par l’utilisateur qui calculera des pourcentages, puis vous appellerez cette fonction et spécifierez les colonnes à utiliser pour calculer le pourcentage.

Dans une instruction let, vous allez déclarer le nom, les arguments et le corps de la fonction à l’aide de la syntaxe générale suivante :

let function=(argument1:datatype, argument2:datatype) {functionbody};

Plus précisément, vous allez utiliser une fonction définie par l’utilisateur pour calculer des pourcentages. Tout d’abord, définissez le type de données et les arguments d’entrée. Pour cet exemple, vous allez utiliser les arguments suivants :

Nom de l’argument	Type de données	Description
portion	real	Partie des événements totaux dont vous souhaitez calculer le pourcentage.
total	real	Nombre total d'événements.

Vous arrondirez la réponse à deux décimales à l’aide de la fonction round().

La fonction définie par l’utilisateur complète décrite par l’instruction let est la suivante :

let Pcent = (portion:real, total:real){round(100 * portion / total, 2)};

1. Utilisez cette instruction let dans la requête suivante :

   Exécuter la requête

   let Pcent = (portion: real, total: real) { round(100 * portion / total, 2) };
   StormEvents
   | extend Damage = DamageCrops + DamageProperty
   | summarize TotalEvents = count(), TotalDamagingEvents = countif(Damage > 0) by EventType
   | project EventType, TotalDamagingEvents, TotalEvents, Percentage = Pcent(TotalDamagingEvents, TotalEvents)
   | sort by EventType asc
   

   Vous devez obtenir des résultats qui ressemblent à l’image suivante :

   

2. Prenez le temps de comprendre les résultats. Essayez de modifier la requête pour afficher une répartition du pourcentage par type de dommage et réexécutez la requête.

Regardez les résultats. Qu’est-ce que le pourcentage signifie ? Notez que la requête appelle la fonction Pcent, que nous avons définie dans l’instruction let. Les entrées utilisées dans cette fonction sont TotalDamagingEvents et TotalEvents, ce qui signifie que vous recherchez le pourcentage d’événements qui ont causé des dommages.

Continuer