Tipo di dati dinamiciThe dynamic data type

Il dynamic tipo di dati scalare è speciale in quanto può assumere qualsiasi valore di altri tipi di dati scalari dall'elenco seguente, nonché matrici e contenitori di proprietà.The dynamic scalar data type is special in that it can take on any value of other scalar data types from the list below, as well as arrays and property bags. In particolare, un dynamic valore può essere:Specifically, a dynamic value can be:

  • Null.Null.
  • Valore di uno dei tipi di dati scalari primitivi: bool , datetime , guid , int , long , real , string e timespan .A value of any of the primitive scalar data types: bool, datetime, guid, int, long, real, string, and timespan.
  • Matrice di dynamic valori, che contiene zero o più valori con indicizzazione in base zero.An array of dynamic values, holding zero or more values with zero-based indexing.
  • Contenitore di proprietà che esegue il mapping string di valori univoci a dynamic valori.A property bag that maps unique string values to dynamic values. Il contenitore delle proprietà contiene zero o più mapping di questo tipo, detti "slot", indicizzati in base ai valori univoci string .The property bag has zero or more such mappings (called "slots"), indexed by the unique string values. Gli slot non sono ordinati.The slots are unordered.

Nota

  • I valori di tipo dynamic sono limitati a 1 MB (2 ^ 20).Values of type dynamic are limited to 1MB (2^20).
  • Sebbene il dynamic tipo appaia come JSON, può mantenere i valori che il modello JSON non rappresenta perché non esistono in JSON, ad esempio,,,, long real datetime timespan e guid .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). Pertanto, durante la serializzazione dynamic dei valori in una rappresentazione JSON, i valori che non possono essere rappresentati da JSON vengono serializzati in string valori.Therefore, in serializing dynamic values into a JSON representation, values that JSON can't represent are serialized into string values. Viceversa, kusto analizzerà le stringhe come valori fortemente tipizzati se possono essere analizzate come tali.Conversely, Kusto will parse strings as strongly-typed values if they can be parsed as such. Questo vale per datetime i real tipi,, long e guid .This applies for datetime, real, long, and guid types. Per ulteriori informazioni sul modello a oggetti JSON, vedere JSON.org.For more about the JSON object model, see json.org.
  • Kusto non tenta di mantenere l'ordine dei mapping nome-valore in un contenitore delle proprietà e pertanto non è possibile presupporre che l'ordine venga mantenuto.Kusto 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. Per due contenitori di proprietà con lo stesso set di mapping è possibile produrre risultati diversi quando sono rappresentati come string valori, ad esempio.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.

Valori letterali dinamiciDynamic literals

Un valore letterale di tipo è dynamic simile al seguente:A literal of type dynamic looks like this:

dynamic( valore )dynamic( Value )

Il valore può essere:Value can be:

  • null, nel qual caso il valore letterale rappresenta il valore dinamico null: dynamic(null) .null, in which case the literal represents the null dynamic value: dynamic(null).
  • Un altro valore letterale del tipo di dati scalare, nel qual caso il valore letterale rappresenta il dynamic valore letterale del tipo "Inner".Another scalar data type literal, in which case the literal represents the dynamic literal of the "inner" type. Ad esempio, dynamic(4) è un valore dinamico che contiene il valore 4 del tipo di dati scalari long.For example, dynamic(4) is a dynamic value holding the value 4 of the long scalar data type.
  • Matrice di valori letterali dinamici o altri: [ listaValori ] .An array of dynamic or other literals: [ ListOfValues ]. Ad esempio, dynamic([1, 2, "hello"]) è una matrice dinamica di tre elementi, due long valori e un string valore.For example, dynamic([1, 2, "hello"]) is a dynamic array of three elements, two long values and one string value.
  • Un contenitore di proprietà: { nome = valore ... }A property bag: { Name = Value ... }. Ad esempio, dynamic({"a":1, "b":{"a":2}}) è un contenitore di proprietà con due slot, a , e b , con il secondo slot che è un altro contenitore delle proprietà.For example, dynamic({"a":1, "b":{"a":2}}) is a property bag with two slots, a, and b, with the second slot being another property bag.
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à, dynamic i valori letterali visualizzati nel testo della query stessa possono includere anche altri valori letterali kusto con i tipi: datetime ,, timespan real , long , guid , bool e dynamic .For convenience, dynamic literals that appear in the query text itself may also include other Kusto literals with types: datetime, timespan, real, long, guid, bool, and dynamic. Questa estensione su JSON non è disponibile durante l'analisi di stringhe, ad esempio quando parse_json si usa la funzione o quando si inseriscono dati, ma consente di eseguire le operazioni seguenti:This extension over JSON isn't available when parsing strings (such as when using the parse_json function or when ingesting data), but it enables you to do the following:

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

Per analizzare un string valore che segue le regole di codifica JSON in un dynamic valore, usare la parse_json funzione.To parse a string value that follows the JSON encoding rules into a dynamic value, use the parse_json function. Ad esempio:For example:

  • parse_json('[43, 21, 65]') : una matrice di numeriparse_json('[43, 21, 65]') - an array of numbers
  • parse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}')-un dizionarioparse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}') - a dictionary
  • parse_json('21') : un singolo valore di tipo dinamico che contiene un numeroparse_json('21') - a single value of dynamic type containing a number
  • parse_json('"21"') : un singolo valore di tipo dinamico che contiene una stringaparse_json('"21"') - a single value of dynamic type containing a string
  • parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}')-Restituisce lo stesso valore dell' o esempio precedente.parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}') - gives the same value as o in the example above.

Nota

A differenza di JavaScript, JSON impone l'uso di caratteri di virgolette doppie ( " ) intorno alle stringhe e ai nomi delle proprietà del contenitore delle proprietà.Unlike JavaScript, JSON mandates the use of double-quote (") characters around strings and property-bag property names. Pertanto, in genere è più semplice racchiudere un valore letterale stringa con codifica JSON usando un carattere virgoletta singola ( ' ).Therefore, it is generally easier to quote a JSON-encoded string literal by using a single-quote (') character.

Nell'esempio seguente viene illustrato come è possibile definire una tabella che contiene una dynamic colonna (oltre a una datetime colonna) e quindi inserirvi un singolo record.The following example shows how you can define a table that holds a dynamic column (as well as a datetime column) and then ingest into it a single record. viene inoltre illustrato come codificare le stringhe JSON nei file CSV:it also demonstrates how you can encode JSON strings in CSV files:

// 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!""}"]
TimestampTimestamp TraceTrace
2015-01-01 00:00:00.00000002015-01-01 00:00:00.0000000 {"EventType": "demo", "EventValue": "doppia citazione Love!"}{"EventType":"Demo","EventValue":"Double-quote love!"}

Funzioni di accesso a oggetti dinamiciDynamic object accessors

Per eseguire l'indicizzazione di un dizionario, utilizzare la notazione del punto ( dict.key ) o la notazione delle parentesi quadre ( dict["key"] ).To subscript a dictionary, use either the dot notation (dict.key) or the brackets notation (dict["key"]). Quando l'indice è una costante di stringa, entrambe le opzioni sono equivalenti.When the subscript is a string constant, both options are equivalent.

Nota

Per utilizzare un'espressione come indice, utilizzare la notazione delle parentesi quadre.To use an expression as the subscript, use the brackets notation. Quando si utilizzano le espressioni aritmetiche, l'espressione all'interno delle parentesi quadre deve essere racchiusa tra parentesi.When using arithmetic expressions, the expression inside the brackets must be wrapped in parentheses.

Negli esempi seguenti dict e arr sono colonne di tipo dinamico:In the examples below dict and arr are columns of dynamic type:

ExpressionExpression Tipo di espressione della funzione di accessoAccessor expression type SignificatoMeaning CommentiComments
dict [col]dict[col] Nome entità (colonna)Entity name (column) Indice di un dizionario usando i valori della colonna col come chiaveSubscripts a dictionary using the values of the column col as the key La colonna deve essere di tipo stringaColumn must be of type string
arr [Indice]arr[index] Indice entità (colonna)Entity index (column) Indicizzazione di una matrice usando i valori della colonna index come indiceSubscripts an array using the values of the column index as the index La colonna deve essere di tipo Integer o BooleanColumn must be of type integer or boolean
arr [-index]arr[-index] Indice entità (colonna)Entity index (column) Recupera il valore "index'-TH" dalla fine della matriceRetrieves the 'index'-th value from the end of the array La colonna deve essere di tipo Integer o BooleanColumn must be of type integer or boolean
arr [(-1)]arr[(-1)] Indice entitàEntity index Recupera l'ultimo valore nella matrice.Retrieves the last value in the array
arr [ToInt (indexAsString)]arr[toint(indexAsString)] Chiamata di funzioneFunction call Esegue il cast dei valori della colonna indexAsString a int e li usa per eseguire l'indicizzazione di una matriceCasts the values of column indexAsString to int and use them to subscript an array
dict [[' Where ']]dict[['where']] Parola chiave utilizzata come nome entità (colonna)Keyword used as entity name (column) Indice di un dizionario usando i valori della colonna where come chiaveSubscripts a dictionary using the values of column where as the key I nomi di entità identici alle parole chiave del linguaggio di query devono essere racchiusi tra virgoletteEntity names that are identical to some query language keywords must be quoted
dict. [' Where '] o dict [' Where ']dict.['where'] or dict['where'] CostanteConstant Indice di un dizionario usando where la stringa come chiaveSubscripts a dictionary using where string as the key

Suggerimento per le prestazioni: Preferisci usare pedici costanti quando possibilePerformance tip: Prefer to use constant subscripts when possible

L'accesso a un oggetto secondario di un dynamic valore genera un altro dynamic valore, anche se l'oggetto secondario presenta un tipo sottostante diverso.Accessing a sub-object of a dynamic value yields another dynamic value, even if the sub-object has a different underlying type. Usare la gettype funzione per individuare il tipo sottostante effettivo del valore e una delle funzioni cast elencate di seguito per eseguirne il cast al tipo effettivo.Use the gettype function to discover the actual underlying type of the value, and any of the cast function listed below to cast it to the actual type.

Cast di oggetti dinamiciCasting dynamic objects

Dopo aver sottoscritto un oggetto dinamico, è necessario eseguire il cast del valore a un tipo semplice.After subscripting a dynamic object, you must cast the value to a simple type.

ExpressionExpression valoreValue TypeType
XX parse_json (' [100101102]')parse_json('[100,101,102]') arrayarray
X [0]X[0] parse_json (' 100')parse_json('100') dinamicodynamic
ToInt (X [1])toint(X[1]) 101101 INTint
SY parse_json (' {"a1": 100, "a b c": "2015-01-01"}')parse_json('{"a1":100, "a b c":"2015-01-01"}') dictionarydictionary
Y. a1Y.a1 parse_json (' 100')parse_json('100') dinamicodynamic
Y ["a b c"]Y["a b c"] parse_json ("2015-01-01")parse_json("2015-01-01") dinamicodynamic
ToDate (Y ["a b c"])todate(Y["a b c"]) DateTime (2015-01-01)datetime(2015-01-01) Datetimedatetime

Le funzioni cast sono:Cast functions are:

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

Compilazione di oggetti dinamiciBuilding dynamic objects

Diverse funzioni consentono di creare nuovi dynamic oggetti:Several functions enable you to create new dynamic objects:

  • Pack () crea un contenitore di proprietà dalle coppie nome/valore.pack() creates a property bag from name/value pairs.
  • pack_array () crea una matrice dalle coppie nome/valore.pack_array() creates an array from name/value pairs.
  • Range () crea una matrice con una serie aritmetica di numeri.range() creates an array with an arithmetic series of numbers.
  • zip () coppie di valori "paralleli" da due matrici in un'unica matrice.zip() pairs "parallel" values from two arrays into a single array.
  • Repeat () crea una matrice con un valore ripetuto.repeat() creates an array with a repeated value.

Sono inoltre disponibili diverse funzioni di aggregazione che consentono dynamic di creare matrici che contengono valori aggregati:Additionally, there are several aggregate functions which create dynamic arrays to hold aggregated values:

  • buildschema () restituisce lo schema di aggregazione di più dynamic valori.buildschema() returns the aggregate schema of multiple dynamic values.
  • make_bag () restituisce un contenitore di proprietà dei valori dinamici all'interno del gruppo.make_bag() returns a property bag of dynamic values within the group.
  • make_bag_if () restituisce un contenitore di proprietà di valori dinamici all'interno del gruppo (con un predicato).make_bag_if() returns a property bag of dynamic values within the group (with a predicate).
  • make_list () restituisce una matrice che contiene tutti i valori, in sequenza.make_list() returns an array holding all values, in sequence.
  • make_list_if () restituisce una matrice che contiene tutti i valori, in sequenza (con un predicato).make_list_if() returns an array holding all values, in sequence (with a predicate).
  • make_list_with_nulls () restituisce una matrice che contiene tutti i valori, in sequenza, inclusi i valori null.make_list_with_nulls() returns an array holding all values, in sequence, including null values.
  • make_set () restituisce una matrice che contiene tutti i valori univoci.make_set() returns an array holding all unique values.
  • make_set_if () restituisce una matrice che contiene tutti i valori univoci (con un predicato).make_set_if() returns an array holding all unique values (with a predicate).

Operatori e funzioni su tipi dinamiciOperators and functions over dynamic types

Operatore o funzioneOperator or function Utilizzo con tipi di dati dinamiciUsage with dynamic data types
valore in matricevalue in array True se è presente un elemento di matrice che è == valoreTrue if there is an element of array that == value
where City in ('London', 'Paris', 'Rome')
valore !in matricevalue !in array True se non è presente un elemento di matrice che è == valoreTrue if there is no element of array that == value
array_length(matrice)array_length(array) Null se non è una matriceNull if it isn't an array
bag_keys(Borsa)bag_keys(bag) Enumera tutte le chiavi radice in un oggetto dinamico del contenitore delle proprietà.Enumerates all the root keys in a dynamic property-bag object.
bag_merge(bag1,..., bagN)bag_merge(bag1,...,bagN) Unisce i contenitori di proprietà dinamici in un contenitore di proprietà dinamico con tutte le proprietà unite.Merges dynamic property-bags into a dynamic property-bag with all properties merged.
extractjson(percorso, oggetto)extractjson(path,object) Usa path per navigare nell'oggetto.Uses path to navigate into object.
parse_json(origine)parse_json(source) Converte una stringa JSON in un oggetto dinamico.Turns a JSON string into a dynamic object.
range(da, a, passaggio)range(from,to,step) Una matrice di valoriAn array of values
mv-expandlistColumnmv-expand listColumn Replica una riga per ogni valore in un elenco in una cella specificata.Replicates a row for each value in a list in a specified cell.
summarize buildschema(colonna)summarize buildschema(column) Deduce lo schema del tipo dal contenuto della colonnaInfers the type schema from column content
summarize make_bag(colonna)summarize make_bag(column) Unisce i valori del contenitore delle proprietà (dizionario) della colonna in un contenitore delle proprietà, senza duplicazione della chiave.Merges the property bag (dictionary) values in the column into one property bag, without key duplication.
summarize make_bag_if(colonna, predicato)summarize make_bag_if(column,predicate) Unisce i valori del contenitore delle proprietà (dizionario) della colonna in un contenitore delle proprietà, senza duplicazione della chiave (con predicato).Merges the property bag (dictionary) values in the column into one property bag, without key duplication (with predicate).
summarize make_list(colonna ) disummarize make_list(column) Rende flat gruppi di righe e inserisce i valori della colonna in una matrice.Flattens groups of rows and puts the values of the column in an array.
summarize make_list_if(colonna, predicato )summarize make_list_if(column,predicate) Rende Flat i gruppi di righe e inserisce i valori della colonna in una matrice (con predicato).Flattens groups of rows and puts the values of the column in an array (with predicate).
summarize make_list_with_nulls(colonna ) disummarize make_list_with_nulls(column) Rende Flat i gruppi di righe e inserisce i valori della colonna in una matrice, inclusi i valori null.Flattens groups of rows and puts the values of the column in an array, including null values.
summarize make_set(colonna)summarize make_set(column) Rende flat gruppi di righe e inserisce i valori della colonna in una matrice, senza duplicazione.Flattens groups of rows and puts the values of the column in an array, without duplication.