Il tipo di dati dinamico

Nota:

* Values of type `dynamic` are limited to 1MB (2^20), uncompressed.

* Although the `dynamic` type appears JSON-like, it can hold values that the JSON
model does not represent because they don't exist in JSON (e.g.,
`long`, `real`, `datetime`, `timespan`, and `guid`).

Therefore, in serializing `dynamic` values into a JSON representation, values that JSON can't represent
are serialized into `string` values. Conversely, KQL will parse strings
as strongly-typed values if they can be parsed as such.
This applies for `datetime`, `real`, `long`, and `guid` types.
For more about the JSON object model, see [json.org](https://json.org/).

* KQL doesn't attempt to preserve the order of name-to-value mappings in
a property bag, and so you can't assume the order to be preserved. It's entirely
possible for two property bags with the same set of mappings to yield different
results when they are represented as `string` values, for example.

Letterali dinamici

Un valore letterale di tipo dynamic è simile al seguente:

dynamic( Valore )

Valore può essere:

• null, nel qual caso il valore letterale rappresenta il valore dinamico null dynamic(null).
• Un altro valore letterale del tipo di dati scalari, nel qual caso il valore letterale rappresenta il valore letterale dynamic del tipo "interno". Ad esempio, dynamic(4) è un valore dinamico che contiene il valore 4 del tipo di dati scalare lungo.
• Un array di valori letterali dinamici o di altro tipo: [ ListOfValues ]. Ad esempio, dynamic([1, 2, "hello"]) è un array dinamico di tre elementi, due valori long e un valore string .
• Un contenitore delle proprietà: { Nome = Valore ... }. Ad esempio, dynamic({"a":1, "b":{"a":2}}) è un bag di proprietà con due slot, ae b, con il secondo slot che è un altro bag di proprietà.

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 comodità, i valori letterali dynamic che vengono visualizzati nel testo della query stesso possono includere anche altri valori letterali Kusto con tipi: datetime, timespan, real, long, guid, boole dynamic. Questa estensione su JSON non è disponibile quando si analizzano le stringhe (ad esempio quando si utilizza la funzione parse_json o quando si inserono i dati), ma ti consente di effettuare le seguenti operazioni:

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

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

• parse_json('[43, 21, 65]') - un array 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 contenente una stringa
• parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}') - fornisce lo stesso valore di o nell'esempio precedente.

// 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!""}"]

Accessor oggetto dinamico

Per deporre un dizionario, utilizzare la notazione del punto (dict.key) o la notazione delle parentesi (dict["key"]). Quando il deponente è una costante stringa, entrambe le opzioni sono equivalenti.

Per utilizzare un'espressione come deponente, utilizzare la notazione delle parentesi. Quando si utilizzano espressioni aritmetiche, l'espressione all'interno delle parentesi deve essere racchiusa tra parentesi.

Negli esempi seguenti, dict e arr sono colonne di tipo dinamico:

Suggerimento per le prestazioni:

Preferisci utilizzare i pedici costanti quando possibile

L'accesso a un oggetto secondario di un valore dynamic produce un altro valore dynamic , anche se l'oggetto secondario ha un tipo sottostante diverso. Utilizzare la funzione gettype per rilevare il tipo sottostante effettivo del valore e qualsiasi funzione cast elencata di seguito per eseguire il cast del tipo effettivo.

Esecuzione del casting di oggetti dinamici

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

Le funzioni cast sono:

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

Creazione di oggetti dinamici

Diverse funzioni consentono di creare nuovi oggetti dynamic :

• zip () associa valori "paralleli" da due array in un singolo array.

Inoltre, ci sono diverse funzioni di aggregazione che creano array dynamic per contenere valori aggregati:

• make_list () restituisce un array che contiene tutti i valori, in sequenza.
• make_list_if () restituisce un array che contiene tutti i valori, in sequenza (con un predicato).
• make_list_with_nulls () restituisce un array che contiene tutti i valori, in sequenza, inclusi i valori null.
• make_set () restituisce un array che contiene tutti i valori univoci.
• make_set_if () restituisce un array che contiene tutti i valori univoci (con un predicato).

Operatori e funzioni su tipi dinamici

Per un elenco completo delle funzioni di array / dinamiche scalari, consultare funzioni di array / dinamiche.

Indicizzazione per dati dinamici

Ogni campo viene indicizzato durante l'inserimento dei dati. L'ambito dell'indice è un singolo frammento di dati.

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