Le type de données dynamiques

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 string uniques à des valeurs dynamic. Le jeu de propriétés comporte zéro, un ou plusieurs de ces mappages (appelés « emplacements »), indexés par les valeurs string uniques. Les emplacements ne sont pas ordonnés.
• Valeur de l’un des types de données scalaires primitifs : bool, datetime, guid, int, long, real, string et timespan.
• Null. Pour plus d’informations, consultez Valeurs Null.

Notes

• Les valeurs de type dynamic sont 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 la valeur MaxValueSize de la colonne en modifiant sa stratégie d’encodage.
• Bien que le dynamic type ressemble à JSON, il peut contenir des valeurs que le modèle JSON ne représente pas, car elles n’existent pas dans JSON (par exemplelong, , real, timespandatetime, et guid). Par conséquent, lors de la sérialisation de valeurs dynamic dans une représentation JSON, les valeurs que JSON ne peut pas représenter sont sérialisées en valeurs string. À 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 datetimetypes , real, longet guid . 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 objet ou un conteneur de propriétés. La valeur d’une clé peut être un conteneur de propriétés imbriquées.	dynamic({"a":1, "b":{"a":2}})
dynamic(value)	Valeur dynamique contenant la valeur du type de données scalaire interne.	dynamic(4)
dynamic(null)	Représente la valeur Null.

Découvrez 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.

Notes

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']	Constante	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 paires nom/valeur.
• 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
ValeurinArray	True s’il existe un élément de tableau qui == valeur where City in ('London', 'Paris', 'Rome')
Valeur!inArray	True s’il n’existe aucun élément du tableau qui == valeur
array_length(array)	Null si ce n’est pas un tableau
bag_has_key(Clé de sac,)	Vérifie si une colonne de sac 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(sac,clé,valeur)	Définit une clé donnée sur une valeur donnée dans un conteneur de propriétés dynamique.
extract_json(chemin,objet), extract_json(chemin d’accès,objet)	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 de 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

Sac de propriétés dynamiques

La requête suivante crée un conteneur de propriétés dynamiques.

Exécuter la requête

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 nombres
• parse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}') : dictionnaire
• parse_json('21') : valeur unique de type dynamique qui contient un nombre
• parse_json('"21"') : valeur unique de type dynamique qui contient une chaîne
• parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}') - donne la même valeur que o dans l’exemple ci-dessus.

Notes

Contrairement à JavaScript, JSON nécessite l’utilisation de caractères guillemets doubles (") autour des chaînes et des noms de propriétés du 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 y ingérer un datetime enregistrement unique. 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 d’interrogation à l’aide d’objets dynamiques et d’accesseurs d’objets, consultez Mapper des valeurs d’un ensemble à un autre.