Le type de données dynamiques
S’applique à : ✅Microsoft Fabric✅Azure Data Explorer✅Azure Monitor✅Microsoft Sentinel
Le dynamic type de données scalaire peut être l’une des valeurs suivantes :
- Tableau de valeurs
dynamic, contenant zéro ou plusieurs valeurs avec une indexation de base zéro. - Jeu de propriétés qui mappe des valeurs
stringuniques à des valeursdynamic. Le jeu de propriétés comporte zéro, un ou plusieurs de ces mappages (appelés « emplacements »), indexés par les valeursstringuniques. Les emplacements ne sont pas ordonnés. - Valeur de l’un des types de données scalaires primitifs :
bool,datetime,guid,int,long,real,stringettimespan. - Null. Pour plus d’informations, consultez valeurs Null.
Remarque
- Les valeurs de type
dynamicsont limitées à 1 Mo (2^20), non compressées. Si une valeur de cellule dans un enregistrement dépasse 1 Mo, la valeur est supprimée et l’ingestion réussit. Vous pouvez augmenter laMaxValueSizecolonne en modifiant sa stratégie d’encodage. - Bien que le
dynamictype apparaisse au format JSON, il peut contenir des valeurs que le modèle JSON ne représente pas, car il n’existe pas dans JSON (par exemplelong,datetimerealtimespanetguid). Par conséquent, lors de la sérialisation de valeursdynamicdans une représentation JSON, les valeurs que JSON ne peut pas représenter sont sérialisées en valeursstring. À l’inverse, Kusto analyse les chaînes en tant que valeurs fortement typées si elles peuvent être analysées en tant que telles. Cela s’applique aux types ,realetlongguidauxdatetimetypes. Pour plus d’informations sur le modèle objet JSON, consultez json.org. - Kusto ne tente pas de conserver l’ordre des mappages de nom à valeur dans un jeu de propriétés, et vous ne pouvez donc pas supposer que l’ordre est conservé. Il est tout à fait possible pour deux jeux de propriétés avec le même jeu de mappages de produire des résultats différents lorsqu’ils sont représentés en tant que valeurs
string, par exemple.
Littéraux dynamiques
Pour spécifier un dynamic littéral, utilisez l’une des options de syntaxe suivantes :
| Syntaxe | Description | Exemple |
|---|---|---|
dynamic([value [, ...]]) |
Tableau de littéraux dynamiques ou d’autres littéraux scalaires. | dynamic([1, 2, "hello"]) |
dynamic({clé value = [, ...]}) |
Un conteneur de propriétés ou un objet. La valeur d’une clé peut être un conteneur de propriétés imbriqué. | dynamic({"a":1, "b":{"a":2}}) |
dynamic(valeur) |
Valeur dynamique contenant la valeur du type de données scalaire interne. | dynamic(4) |
dynamic(null) |
Représente la valeur Null. |
En savoir plus sur les conventions de syntaxe.
Accesseurs d’objets dynamiques
Pour mettre un dictionnaire en indice, utilisez la notation en points (dict.key) ou la notation en crochets (dict["key"]). Lorsque l’indice est une constante de chaîne, les deux options sont équivalentes.
Remarque
Pour utiliser une expression comme indice, utilisez la notation en crochets. Lorsque vous utilisez des expressions arithmétiques, l’expression à l’intérieur des crochets doit être placée entre parenthèses.
Dans les exemples ci-dessous, dict et arr sont des colonnes de type dynamique :
| Expression | Type d’expression d’accesseur | Signification | Commentaires |
|---|---|---|---|
| dict[col] | Nom de l’entité (colonne) | Met en indice un dictionnaire à l’aide des valeurs de la colonne col comme clé |
La colonne doit être de type chaîne |
| arr[index] | Index d’entité (colonne) | Met en indice un tableau à l’aide des valeurs de la colonne index comme index |
La colonne doit être de type entier ou booléen |
| arr[-index] | Index d’entité (colonne) | Récupère la valeur « index-th » à partir de la fin du tableau | La colonne doit être de type entier ou booléen |
| arr[(-1)] | Index d’entité | Récupère la dernière valeur dans le tableau | |
| arr[toint(indexAsString)] | Appel de fonction | Effectue un cast des valeurs de la colonne indexAsString en valeur int et les utilise pour mettre en indice un tableau |
|
| dict[['where']] | Mot clé utilisé comme nom d’entité (colonne) | Met en indice un dictionnaire à l’aide des valeurs de la colonne where comme clé |
Les noms d’entité identiques à certains mots clés de langage de requête doivent être placés entre guillemets. |
| dict.['where'] ou dict['where'] | Constant | Met en indice un dictionnaire à l’aide de la chaîne where comme clé |
Conseil
Nous vous recommandons d’utiliser des indices constants lorsque cela est possible.
L’accès à un sous-objet d’une valeur dynamic produit une autre valeur dynamic, même si le sous-objet a un type sous-jacent différent. Utilisez la fonction gettype pour découvrir le type sous-jacent réel de la valeur et l’une des fonctions cast listées ci-dessous pour effectuer un cast vers le type réel.
Cast d’objets dynamiques
Après avoir mis en indice un objet dynamique, vous devez effectuer un cast de la valeur en un type simple.
| Expression | Valeur | Type |
|---|---|---|
| X | parse_json('[100,101,102]') | tableau |
| X[0] | parse_json('100') | dynamic |
| toint(X[1]) | 101 | int |
| Y | parse_json('{"a1":100, "a b c":"2015-01-01"}') | dictionnaire |
| Y.a1 | parse_json('100') | dynamic |
| Y["a b c"] | parse_json("2015-01-01") | dynamic |
| todate(Y["a b c"]) | datetime(2015-01-01) | datetime |
Les fonctions cast sont les suivantes :
tolong()todouble()todatetime()totimespan()tostring()toguid()parse_json()
Génération d’objets dynamiques
Plusieurs fonctions vous permettent de créer des objets dynamic :
- bag_pack() crée un conteneur de propriétés à partir de paires nom/valeur.
- pack_array() crée un tableau à partir de la liste des valeurs (peut être la liste des colonnes, pour chaque ligne, il crée un tableau à partir des colonnes spécifiées).
- range() crée un tableau avec une série arithmétique de nombres.
- zip() appaire les valeurs « parallèles » de deux tableaux en un seul tableau.
- repeat() crée un tableau avec une valeur répétée.
En outre, il existe plusieurs fonctions d’agrégation qui créent des tableaux dynamic pour contenir des valeurs agrégées :
- buildschema() retourne le schéma d’agrégation de plusieurs valeurs
dynamic. - make_bag() retourne un jeu de propriétés de valeurs dynamiques dans le groupe.
- make_bag_if() retourne un jeu de propriétés de valeurs dynamiques dans le groupe (avec un prédicat).
- make_list() retourne un tableau contenant toutes les valeurs, dans l’ordre.
- make_list_if() retourne un tableau contenant toutes les valeurs, dans l’ordre (avec un prédicat).
- make_list_with_nulls() retourne un tableau contenant toutes les valeurs, dans l’ordre, y compris les valeurs null.
- make_set() retourne un tableau contenant toutes les valeurs uniques.
- make_set_if() retourne un tableau contenant toutes les valeurs uniques (avec un prédicat).
Opérateurs et fonctions sur des types dynamiques
Pour obtenir la liste complète des fonctions scalaires dynamiques/de tableau, consultez Fonctions dynamiques/de tableau.
| Opérateur ou fonction | Utilisation avec des types de données dynamiques |
|---|---|
tableau de valeurs in |
True s’il existe un élément de tableau qui == valeur where City in ('London', 'Paris', 'Rome') |
tableau de valeurs !in |
True s’il n’existe aucun élément de tableau qui == valeur |
array_length(array) |
Null si ce n’est pas un tableau |
bag_has_key(touche de sac,) |
Vérifie si une colonne de conteneur dynamique contient une clé donnée. |
bag_keys(bag) |
Énumère toutes les clés racines dans un objet de jeu de propriétés dynamique. |
bag_merge(bag1,...,bagN) |
Fusionne des jeux de propriétés dynamiques dans un jeu de propriétés dynamique avec toutes les propriétés fusionnées. |
bag_set_key(bag,key,value) |
Définit une clé donnée sur une valeur donnée dans un conteneur de propriétés dynamiques. |
extract_json(path,object), extract_json(path,object) |
Utilisez le chemin d’accès pour accéder à l’objet. |
parse_json(source) |
Convertit une chaîne JSON en un objet dynamique. |
range(from,to,step) |
Tableau de valeurs . |
mv-expand listColumn |
Réplique une ligne pour chaque valeur d’une liste dans une cellule spécifiée. |
summarize buildschema(column) |
Déduit le schéma de type à partir du contenu de colonne. |
summarize make_bag(column) |
Fusionne les valeurs du jeu de propriétés (dictionnaire) de la colonne dans un jeu de propriétés, sans duplication de clé. |
summarize make_bag_if(column,predicate) |
Fusionne les valeurs du jeu de propriétés (dictionnaire) de la colonne dans un jeu de propriétés, sans duplication de clé (avec un prédicat). |
summarize make_list(column) |
Aplatit des groupes de lignes et place les valeurs de la colonne dans un tableau. |
summarize make_list_if(column,predicate) |
Aplatit des groupes de lignes et place les valeurs de la colonne dans un tableau (avec un prédicat). |
summarize make_list_with_nulls(column) |
Aplatit des groupes de lignes et place les valeurs de la colonne dans un tableau, y compris les valeurs null. |
summarize make_set(column) |
Aplatit des groupes de lignes et place les valeurs de la colonne dans un tableau, sans duplication. |
Indexation pour les données dynamiques
Chaque champ est indexé pendant l’ingestion des données. L’étendue de l’index est une partition de données unique.
Pour indexer des colonnes dynamiques, le processus d’ingestion énumère tous les éléments « atomiques » dans la valeur dynamique (noms de propriétés, valeurs, éléments de tableau) et les transfère au générateur d’index. Sinon, les champs dynamiques ont le même index de terme inversé que les champs de chaîne.
Exemples
Conteneur de propriétés dynamiques
La requête suivante crée un conteneur de propriétés dynamique.
print o=dynamic({"a":123, "b":"hello", "c":[1,2,3], "d":{}})
| extend a=o.a, b=o.b, c=o.c, d=o.d
Pour plus de commodité, les littéraux dynamic qui apparaissent dans le texte de la requête peuvent également inclure d’autres littéraux Kusto avec les types suivants : datetime, timespan, real, long, guid, bool et dynamic.
Cette extension sur JSON n’est pas disponible lors de l’analyse de chaînes (par exemple, lors de l’utilisation de la fonction parse_json ou lors de l’ingestion de données), mais elle vous permet d’effectuer les opérations suivantes :
print d=dynamic({"a": datetime(1970-05-11)})
Pour analyser une valeur string qui suit les règles d’encodage JSON dans une valeur dynamic, utilisez la fonction parse_json. Par exemple :
parse_json('[43, 21, 65]'): tableau de nombresparse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}'): dictionnaireparse_json('21'): valeur unique de type dynamique qui contient un nombreparse_json('"21"'): valeur unique de type dynamique qui contient une chaîneparse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}'): donne la même valeur queodans l’exemple ci-dessus.
Remarque
Contrairement à JavaScript, JSON nécessite l’utilisation de caractères entre guillemets doubles (") autour des chaînes et des noms de propriétés de conteneur de propriétés. Ainsi, il est généralement plus facile de placer les littéraux de chaîne JSON entre des apostrophes (').
Ingérer des données dans des colonnes dynamiques
L’exemple suivant montre comment définir une table qui contient une dynamic colonne (ainsi qu’une colonne), puis ingérer un enregistrement unique dans celui-ci datetime . Il montre également comment encoder des chaînes JSON dans des fichiers CSV.
// dynamic is just like any other type:
.create table Logs (Timestamp:datetime, Trace:dynamic)
// Everything between the "[" and "]" is parsed as a CSV line would be:
// 1. Since the JSON string includes double-quotes and commas (two characters
// that have a special meaning in CSV), we must CSV-quote the entire second field.
// 2. CSV-quoting means adding double-quotes (") at the immediate beginning and end
// of the field (no spaces allowed before the first double-quote or after the second
// double-quote!)
// 3. CSV-quoting also means doubling-up every instance of a double-quotes within
// the contents.
.ingest inline into table Logs
[2015-01-01,"{""EventType"":""Demo"", ""EventValue"":""Double-quote love!""}"]
Sortie
| Timestamp | Trace |
|---|---|
| 2015-01-01 00:00:00.0000000 | {"EventType":"Demo","EventValue":"Double-quote love!"} |
Contenu connexe
- Pour obtenir un exemple sur la façon d’interroger à l’aide d’objets dynamiques et d’accesseurs d’objets, consultez Mapper des valeurs d’un ensemble à un autre.