Tipo di dati dynamic
Si applica a: ✅Microsoft Fabric✅Azure Esplora dati✅ Azure Monitor✅Microsoft Sentinel
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
stringunivoci a valoridynamic. Il contenitore di proprietà include zero o più mapping di questo tipo, definiti "slot", indicizzati in base ai valoristringunivoci. Gli slot non sono ordinati. - Un valore di qualsiasi tipo di dati scalare primitivo:
bool,datetime,guid,int,long,real,stringetimespan. - Null. Per altre informazioni, vedere Valori Null.
Nota
- I valori di tipo
dynamicsono 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 laMaxValueSizeproprietà della colonna modificandone i criteri di codifica. - Anche se il
dynamictipo appare come JSON, può contenere valori che il modello JSON non rappresenta perché non esistono in JSON (ad esempiolong, ,realdatetime, ,timespaneguid). Pertanto, nella serializzazione di valoridynamicin una rappresentazione JSON, i valori che JSON non può rappresentare vengono serializzati in valoristring. Viceversa, Kusto analizzerà le stringhe come valori fortemente tipizzati, se possono essere analizzati come tali. Questo vale perdatetimei tipi ,longreal, eguid. 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, utilizzare una delle opzioni di sintassi seguenti:
| Sintassi | Descrizione | Esempio |
|---|---|---|
dynamic([value [, ...]]) |
Matrice di valori letterali scalari o dinamici. | dynamic([1, 2, "hello"]) |
dynamic({valore chiave = [, ...]}) |
Contenitore delle proprietà o oggetto . Il valore di 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:
| Espressione | 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 pedice 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.
| Espressione | Valore | Type |
|---|---|---|
| X | parse_json('[100,101,102]') | array |
| X[0] | parse_json('100') | dynamic |
| toint(X[1]) | 101 | int |
| Y | parse_json('{"a1":100, "a b c":"2015-01-01"}') | dizionario |
| 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 un elenco di valori (può essere un elenco di colonne, per ogni riga verrà creata una matrice dalle colonne specificate).
- 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 |
|---|---|
matrice di valori in |
True se è presente un elemento della matrice che == valore where City in ('London', 'Paris', 'Rome') |
matrice di valori !in |
True se non è presente alcun elemento della matrice che == valore |
array_length(array) |
Null se non è una matrice |
bag_has_key(portachiava,) |
Controlla se una colonna contenitore dinamica 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 determinata chiave su un determinato valore in un contenitore di proprietà dinamico. |
extract_json(path,object), extract_json(path,object) |
Usare il percorso per spostarsi nell'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) |
Deduce lo schema del 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 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 di matrice) e li inoltra al generatore di indici. In caso contrario, i campi dinamici hanno lo stesso indice di termini invertito dei campi stringa.
Esempi
Contenitore delle proprietà dinamiche
La query seguente crea un contenitore di proprietà dinamiche.
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 numeriparse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}'): un dizionarioparse_json('21'): un singolo valore di tipo dinamico che contiene un numeroparse_json('"21"'): un singolo valore di tipo dinamico che contiene una stringaparse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}'): fornisce lo stesso valore diodell'esempio seguente.
Nota
A differenza di JavaScript, JSON richiede l'uso di caratteri tra virgolette doppie (") per le stringhe e i nomi delle 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 contenente una dynamic colonna (nonché una datetime colonna) e quindi inserirla in un singolo record. 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: | Traccia |
|---|---|
| 2015-01-01 00:00:00.0000000 | {"EventType":"Demo","EventValue":"Double-quote love!"} |
Contenuto correlato
- 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.