Tipo di dati dynamic

Il dynamic tipo di dati scalare può essere uno dei valori seguenti:

• Una matrice di valori dynamic, contenente zero o più valori con indicizzazione in base zero.
• Un contenitore di proprietà che mappa valori string univoci a valori dynamic. Il contenitore di proprietà include zero o più mapping di questo tipo, definiti "slot", indicizzati in base ai valori string univoci. Gli slot non sono ordinati.
• Un valore di qualsiasi tipo di dati scalare primitivo: bool, datetime, guid, int, long, real, string e timespan.
• Null. Per altre informazioni, vedere Valori Null.

Nota

• I valori di tipo dynamic sono limitati a 1 MB (2^20), non compressi. Se un valore di cella in un record supera 1 MB, il valore viene eliminato e l'inserimento ha esito positivo. È possibile aumentare l'oggetto della colonna modificando i MaxValueSizecriteri di codifica.
• Anche se il tipo viene visualizzato come JSON, può contenere valori che il dynamic modello JSON non rappresenta perché non esistono in JSON (ad esempio long, timespanrealdatetimee ).guid Pertanto, nella serializzazione di valori dynamic in una rappresentazione JSON, i valori che JSON non può rappresentare vengono serializzati in valori string. Viceversa, Kusto analizzerà le stringhe come valori fortemente tipizzati, se possono essere analizzati come tali. Ciò si applica ai datetimetipi , real, longe guid . Per altre informazioni sul modello a oggetti JSON, vedere json.org.
• Kusto non prova a preservare l'ordine dei mapping nome-valore in un contenitore di proprietà, quindi non è possibile presupporre che tale ordine venga mantenuto. È interamente possibile che due contenitori di proprietà con lo stesso set di mapping generino risultati diversi quando vengono rappresentati, ad esempio, come valori string.

Valori letterali dinamici

Per specificare un dynamic valore letterale, usare una delle opzioni di sintassi seguenti:

Sintassi	Descrizione	Esempio
dynamic([value [, ...]])	Matrice di valori letterali scalari o dinamici.	dynamic([1, 2, "hello"])
dynamic({Chiave=value [, ...]})	Oggetto o borsa delle proprietà. Il valore per una chiave può essere un contenitore di proprietà annidato.	dynamic({"a":1, "b":{"a":2}})
dynamic(value)	Valore dinamico che contiene il valore del tipo di dati scalare interno.	dynamic(4)
dynamic(null)	Rappresenta il valore Null.

Altre informazioni sulle convenzioni di sintassi.

Funzioni di accesso di oggetti dinamici

Per indicizzare un dizionario, usare la notazione con il punto (dict.key) o con le parentesi quadre (dict["key"]). Se l'indice è una costante stringa, le due opzioni sono equivalenti.

Nota

Per usare un'espressione come indice, usare la notazione con parentesi quadre. Se si usano espressioni aritmetiche, l'espressione all'interno delle parentesi quadre deve essere racchiusa tra parentesi tonde.

Negli esempi seguenti dict e arr sono colonne di tipo dynamic:

Expression	Tipo di espressione delle funzione di accesso	Significato	Commenti
dict[col]	Nome dell'entità (colonna)	Indicizza un dizionario usando i valori della colonna col come chiave	La colonna deve essere di tipo string
arr[index]	Indice dell'entità (colonna)	Indicizza una matrice usando i valori della colonna index come indice	La colonna deve essere di tipo integer o boolean
arr[-index]	Indice dell'entità (colonna)	Recupera il valore dell'oggetto 'index' indicato dalla fine della matrice	La colonna deve essere di tipo integer o boolean
arr[(-1)]	Indice di entità	Recupera l'ultimo valore nella matrice
arr[toint(indexAsString)]	Chiamata di funzione	Esegue il cast dei valori della colonna indexAsString a int e li usa per indicizzare una matrice
dict[['where']]	Parola chiave usata come nome dell'entità (colonna)	Indicizza un dizionario usando i valori della colonna where come chiave	I nomi delle entità identici a parole chiave di qualche linguaggio di query devono essere racchiusi tra virgolette
dict.['where'] o dict['where']	Costante	Indicizza un dizionario usando la stringa where come chiave

Suggerimento

È consigliabile usare i sottoscritti costanti quando possibile.

L'accesso a un oggetto secondario di un valore dynamic genera un altro valore dynamic, anche se l'oggetto secondario ha un tipo sottostante diverso. Usare la funzione gettype per individuare il tipo sottostante effettivo del valore e una delle funzioni cast elencate di seguito per eseguirne il cast al tipo effettivo.

Cast di oggetti dinamici

Dopo aver indicizzato un oggetto dinamico, è necessario eseguire il cast del valore a un tipo semplice.

Expression	Valore	Tipo
X	parse_json('[100,101,102]')	array
X[0]	parse_json('100')	dynamic
toint(X[1])	101	int
S	parse_json('{"a1":100, "a b c":"2015-01-01"}')	dictionary
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

Le funzioni cast sono:

• tolong()
• todouble()
• todatetime()
• totimespan()
• tostring()
• toguid()
• parse_json()

Creazione di oggetti dinamici

Diverse funzioni consentono di creare nuovi oggetti dynamic:

• bag_pack() crea un contenitore di proprietà da coppie nome/valore.
• pack_array() crea una matrice da coppie nome-valore.
• range() crea una matrice con una serie aritmetica di numeri.
• zip() abbina i valori "paralleli" di due matrici in una singola matrice.
• repeat() crea una matrice con un valore ripetuto.

Inoltre, sono disponibili diverse funzioni di aggregazione che creano matrici dynamic in cui contenere valori aggregati:

• buildschema() restituisce lo schema aggregato di più valori dynamic.
• make_bag() restituisce un contenitore di proprietà di valori dinamici all'interno del gruppo.
• make_bag_if() restituisce un contenitore di proprietà di valori dinamici all'interno del gruppo (con un predicato).
• make_list() restituisce una matrice che contiene tutti i valori in sequenza.
• make_list_if() restituisce una matrice che contiene tutti i valori in sequenza (con un predicato).
• make_list_with_nulls() restituisce una matrice che contiene tutti i valori in sequenza, inclusi i valori Null.
• make_set() restituisce una matrice che contiene tutti valori univoci.
• make_set_if() restituisce una matrice che contiene tutti valori univoci (con un predicato).

Operatori e funzioni su tipi dinamici

Per un elenco completo di funzioni scalari su tipi dinamici/matrici, vedere Funzioni su tipi dinamici/matrici.

Operatore o funzione	Utilizzo con i tipi di dati dinamici
ValoreinMatrice	True se è presente un elemento della matrice che == valore where City in ('London', 'Paris', 'Rome')
Valore!inMatrice	True se non è presente alcun elemento della matrice che == valore
array_length(matrice)	Null se non è una matrice
bag_has_key(chiave di borsa,)	Verifica se una colonna del contenitore dinamico contiene una chiave specificata.
bag_keys(bag)	Enumera tutte le chiavi radice in un oggetto contenitore di proprietà dinamiche.
bag_merge(bag1,...,bagN)	Unisce i contenitori di proprietà dinamiche in un contenitore di proprietà dinamiche con tutte le proprietà unite.
bag_set_key(borsa, chiave, valore)	Imposta una chiave specificata su un determinato valore in un contenitore di proprietà dinamico.
extract_json(path,object), extract_json(path,object)	Usare il percorso per passare all'oggetto.
parse_json(source)	Converte una stringa JSON in un oggetto dinamico.
range(from,to,step)	Matrice di valori .
mv-expand listColumn	Replica una riga per ogni valore in un elenco in una cella specificata.
summarize buildschema(column)	Inferisce lo schema di tipo dal contenuto della colonna.
summarize make_bag(column)	Unisce i valori del contenitore di proprietà (dizionario) della colonna in un unico contenitore di proprietà, senza duplicazione di chiavi.
summarize make_bag_if(column,predicate)	Unisce i valori del contenitore di proprietà (dizionario) della colonna in un unico contenitore di proprietà, senza duplicazione di chiavi (con predicato).
summarize make_list(column)	Rende flat gruppi di righe e inserisce i valori della colonna in una matrice.
summarize make_list_if(column,predicate)	Appiattisce gruppi di righe e inserisce i valori della colonna in una matrice (con predicato).
summarize make_list_with_nulls(column)	Appiattisce gruppi di righe e inserisce i valori della colonna in una matrice, inclusi i valori Null.
summarize make_set(column)	Rende flat gruppi di righe e inserisce i valori della colonna in una matrice, senza duplicazione.

Indicizzazione per i dati dinamici

Ogni campo viene indicizzato durante l'inserimento dei dati. L'ambito dell'indice è una singola partizione di dati.

Per indicizzare le colonne dinamiche, il processo di inserimento enumera tutti gli elementi "atomici" all'interno del valore dinamico (nomi di proprietà, valori, elementi matrice) e li inoltra al generatore di indici. In caso contrario, i campi dinamici hanno lo stesso indice termine invertito dei campi stringa.

Esempio

Borsa di proprietà dinamica

La query seguente crea un contenitore di proprietà dinamico.

Eseguire la query

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

Per praticità, i valori letterali dynamic inclusi nel testo stesso della query possono anche includere altri valori letterali Kusto con i tipi datetime, timespan, real, long, guid, bool e dynamic. Questa estensione rispetto a JSON non è disponibile per l'analisi di stringhe, ad esempio quando si usa la funzione parse_json o si inseriscono dati, ma consente di eseguire quanto segue:

print d=dynamic({"a": datetime(1970-05-11)})

Per analizzare un valore string che segue le regole di codifica JSON in un valore dynamic, usare la funzione parse_json. Ad esempio:

• parse_json('[43, 21, 65]') : una matrice di numeri
• parse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}'): un dizionario
• parse_json('21') : un singolo valore di tipo dinamico che contiene un numero
• parse_json('"21"') : un singolo valore di tipo dinamico che contiene una stringa
• parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}') - assegna lo stesso valore o dell'esempio precedente.

Nota

A differenza di JavaScript, JSON richiede l'uso di caratteri con virgolette doppie (") intorno a stringhe e nomi di proprietà del contenitore di proprietà. Pertanto, è in genere più facile usare il carattere virgolette singole (') per un valore letterale stringa con codifica JSON.

Inserire dati in colonne dinamiche

Nell'esempio seguente viene illustrato come definire una tabella che contiene una colonna (oltre a una dynamicdatetime colonna) e quindi inserire un singolo record in esso. Illustra anche come codificare stringhe JSON nei file 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!""}"]

Output

Timestamp	Trace
2015-01-01 00:00:00.0000000	{"EventType":"Demo","EventValue":"Double-quote love!"}

Contenuti correlati

• Per un esempio su come eseguire query usando oggetti dinamici e funzioni di accesso agli oggetti, vedere Eseguire il mapping dei valori da un set a un altro.