Let, instruction
S’applique à : ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel
Une let instruction est utilisée pour définir un nom de variable égal à une expression ou une fonction, ou pour créer des vues.
Les instructions let sont utiles pour :
- Décomposer une expression complexe en plusieurs parties, chacune étant représentée par une variable.
- Définir des constantes en dehors du corps de la requête, pour des raisons de lisibilité.
- Définir une variable une seule fois et l’utiliser plusieurs fois dans une requête.
Si la variable représentait auparavant une autre valeur, par exemple dans des instructions imbriquées, l’instruction let la plus à l’intérieur s’applique.
Pour optimiser plusieurs utilisations de l’instruction let dans une même requête, consultez Optimiser les requêtes qui utilisent des expressions nommées.
Remarque
L’instruction let lie un nom à un calcul, et non à la valeur évaluée de ce calcul. Ce comportement signifie que plusieurs références au même nom peuvent retourner différentes valeurs en raison du calcul évalué plusieurs fois. Si ce n’est pas le comportement souhaité, utilisez toscalar() ou matérialisez().
Syntaxe : expressions scalaires ou tabulaires
letNom = Expression
Important
Les instructions let doivent être suivies d’un point-virgule. Il ne peut pas y avoir de ligne vide entre les instructions let ou entre les instructions let et d’autres instructions de requête.
En savoir plus sur les conventions de syntaxe.
Paramètres
| Nom | Type | Requise | Description |
|---|---|---|---|
| Nom | string |
✔️ | Nom de la variable. Vous pouvez placer le nom en échappement avec des crochets. Par exemple : ["Name with spaces"]. |
| Expression | string |
✔️ | Une expression avec un résultat scalaire ou tabulaire. Par exemple, une expression avec un résultat scalaire serait let one=1;, et une expression avec un résultat tabulaire serait let RecentLog = Logs | where Timestamp > ago(1h). |
Syntaxe : vue ou fonction
letNom = [view] ([ Paramètres ]) { FunctionBody }
Important
Les instructions let doivent être suivies d’un point-virgule. Il ne peut pas y avoir de ligne vide entre les instructions let ou entre les instructions let et d’autres instructions de requête.
En savoir plus sur les conventions de syntaxe.
Paramètres
| Nom | Type | Requise | Description |
|---|---|---|---|
| Corps_fonction | string |
✔️ | Une expression qui produit une fonction définie par l’utilisateur. |
view |
string |
Concerne seulement une instruction let sans paramètres. Quand elle est utilisée, l’instruction let est incluse dans les requêtes avec un opérateur union, avec une sélection de caractères génériques des tables/vues. Pour obtenir un exemple, consultez Créer une vue ou une table virtuelle. |
|
| Paramètres | string |
Zéro ou plusieurs paramètres de fonction tabulaires ou scalaires, séparés par une virgule. Pour chaque paramètre de type tabulaire, le paramètre doit être au format Nom_table :Schéma_table, où Schéma_table est une liste de colonnes séparées par une virgule au format Nom_colonne:Type_colonne ou un caractère générique (*). Si des colonnes sont spécifiées, l’argument tabulaire d’entrée doit contenir ces colonnes. Si un caractère générique est spécifié, l’argument tabulaire d’entrée peut avoir n’importe quel schéma. Pour référencer des colonnes dans le corps de la fonction, elles doivent être spécifiées. Pour obtenir des exemples, consultez Argument tabulaire avec schéma et Argument tabulaire avec caractère générique.Pour chaque paramètre de type scalaire, spécifiez le nom du paramètre et le type de paramètre au formatNom :Type. Le nom peut apparaître dans Corps_fonction et est lié à une valeur particulière quand la fonction définie par l’utilisateur est appelée. Les seuls types pris en charge sont bool, string, longdatetime, timespan, real, dynamic et les alias de ces types. |
Notes
- Les paramètres tabulaires doivent apparaître avant les paramètres scalaires.
- Deux instructions doivent être séparées par un point-virgule.
Exemples
Définir des valeurs scalaires
L’exemple suivant utilise une instruction d’expression scalaire.
let n = 10; // number
let place = "Dallas"; // string
let cutoff = ago(62d); // datetime
Events
| where timestamp > cutoff
and city == place
| take n
L’exemple suivant lie le nom some number en utilisant la notation ['name'], puis l’utilise dans une instruction d’expression tabulaire.
let ['some number'] = 20;
range y from 0 to ['some number'] step 5
Créer une fonction définie par l’utilisateur avec un calcul scalaire
L’exemple suivant utilise l’instruction Let avec des arguments pour le calcul scalaire. La requête définit la fonction MultiplyByN pour la multiplication de deux nombres.
let MultiplyByN = (val:long, n:long) { val * n };
range x from 1 to 5 step 1
| extend result = MultiplyByN(x, 5)
Sortie
| x | result |
|---|---|
| 1 | 5 |
| 2 | 10 |
| 3 | 15 |
| 4 | 20 |
| 5 | 25 |
Créer une fonction définie par l’utilisateur qui supprime les espaces de l’entrée
L’exemple suivant supprime les espaces de début et de fin de l’entrée.
let TrimOnes = (s:string) { trim("1", s) };
range x from 10 to 15 step 1
| extend result = TrimOnes(tostring(x))
Sortie
| x | result |
|---|---|
| 10 | 0 |
| 11 | |
| 12 | 2 |
| 13 | 3 |
| 14 | 4 |
| 15 | 5 |
Utiliser plusieurs instructions Let
Cet exemple définit deux instructions Let où une instruction (foo2) en utilise une autre (foo1).
let foo1 = (_start:long, _end:long, _step:long) { range x from _start to _end step _step};
let foo2 = (_step:long) { foo1(1, 100, _step)};
foo2(2) | count
Sortie
| result |
|---|
| 50 |
Créer une vue ou une table virtuelle
Cet exemple vous montre comment utiliser une instruction let pour créer une view ou une table virtuelle.
let Range10 = view () { range MyColumn from 1 to 10 step 1 };
let Range20 = view () { range MyColumn from 1 to 20 step 1 };
search MyColumn == 5
Sortie
| $table | MyColumn |
|---|---|
| Range10 | 5 |
| Range20 | 5 |
Utiliser une fonction materialize
La fonction materialize() vous permet de mettre en cache les résultats de la sous-requête au moment de l’exécution de la requête. Quand vous utilisez la fonction materialize(), les données sont mises en cache et toute appel ultérieur du résultat utilise les données mises en cache.
let totalPagesPerDay = PageViews
| summarize by Page, Day = startofday(Timestamp)
| summarize count() by Day;
let materializedScope = PageViews
| summarize by Page, Day = startofday(Timestamp);
let cachedResult = materialize(materializedScope);
cachedResult
| project Page, Day1 = Day
| join kind = inner
(
cachedResult
| project Page, Day2 = Day
)
on Page
| where Day2 > Day1
| summarize count() by Day1, Day2
| join kind = inner
totalPagesPerDay
on $left.Day1 == $right.Day
| project Day1, Day2, Percentage = count_*100.0/count_1
Sortie
| Jour1 | Jour2 | Pourcentage |
|---|---|---|
| 2016-05-01 00:00:00.0000000 | 2016-05-02 00:00:00.0000000 | 34,0645725975255 |
| 2016-05-01 00:00:00.0000000 | 2016-05-03 00:00:00.0000000 | 16,618368960101 |
| 2016-05-02 00:00:00.0000000 | 2016-05-03 00:00:00.0000000 | 14,6291376489636 |
Utilisation d’instructions let imbriquées
Les instructions let imbriquées sont autorisées, y compris dans une expression de fonction définie par l’utilisateur. Les instructions et les arguments Let s’appliquent à la fois dans l’étendue active et intérieure du corps de la fonction.
let start_time = ago(5h);
let end_time = start_time + 2h;
T | where Time > start_time and Time < end_time | ...
Argument tabulaire avec schéma
L’exemple suivant spécifie que le paramètre de table Tdoit avoir une colonne State de type string. La table T peut également inclure d’autres colonnes, mais elles ne peuvent pas être référencées dans la fonction StateState, car elles ne sont pas déclarées.
let StateState=(T: (State: string)) { T | extend s_s=strcat(State, State) };
StormEvents
| invoke StateState()
| project State, s_s
Sortie
| State | s_s |
|---|---|
| ATLANTIQUE SUD | ATLANTIC SOUTHATLANTIC SOUTH |
| FLORIDE | FLORIDAFLORIDA |
| FLORIDE | FLORIDAFLORIDA |
| GEORGIE | GEORGIAGEORGIA |
| MISSISSIPPI | MISSISSIPPIMISSISSIPPI |
| ... | ... |
Argument tabulaire avec caractère générique
Le paramètre de table T peut avoir n’importe quel schéma, et la fonction CountRecordsInTable va fonctionner.
let CountRecordsInTable=(T: (*)) { T | count };
StormEvents | invoke CountRecordsInTable()
Sortie
| Count |
|---|
| 59 066 |