O tipo de dados dinâmico

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.

Literais dinâmicos

Um literal do tipo dynamic é semelhante a este:

dynamic( Valor )

Valor pode ser:

• null, nesse caso, o literal representa o valor dinâmico nulo: dynamic(null).
• Outro literal de tipo de dados escalares, nesse caso, o literal representa o literal dynamic do tipo "interno".. Por exemplo, dynamic(4) é um valor dinâmico contendo o valor 4 do tipo de dados escalares longos.
• Uma matriz de literais dinâmicos ou outros: [ ListOfValores ]. Por exemplo, dynamic([1, 2, "hello"]) é uma matriz dinâmica de três elementos, dois valores long e um valor string .
• Um pacote de propriedades: { Nome = Valor ... } Por exemplo, dynamic({"a":1, "b":{"a":2}}) é um pacote de propriedades com dois slots, a, e b, com o segundo slot sendo outro pacote de propriedade

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

Por conveniência, os literais dynamic que aparecem no próprio texto da consulta também podem incluir outros literais Kusto com tipos: datetime, timespan, real, long, guid, boole dynamic. Essa extensão sobre JSON não está disponível ao analisar sequências (como ao usar a função parse_json ou ao alimentar dados), mas permite que você faça o seguinte:

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

Para analisar um valor string que segue as regras de codificação JSON em um valor dynamic , use a função parse_json . Por exemplo:

• parse_json('[43, 21, 65]') -uma matriz de números
• parse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}') -um dicionário
• parse_json('21') -um valor único de tipo dinâmico contendo um número
• parse_json('"21"') -um valor único de tipo dinâmico contendo uma cadeia
• parse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}') -fornece o mesmo valor que o no exemplo acima

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

Acessadores de objeto dinâmico

Para assinar um dicionário, use a notação de ponto (dict.key) ou a notação de colchetes (dict["key"]).. Quando o subscript é uma constante de cadeia, ambas as opções são equivalentes.

Para usar uma expressão como o subscrito, use a notação de colchetes. Ao usar expressões aritméticas, a expressão dentro dos colchetes deve estar entre parênteses.

Nos exemplos abaixo, dict e arr são colunas de tipo dinâmico:

Dica de desempenho:

Prefira usar subscritos constantes quando possível.

Acessar um subobjeto de um valor dynamic produz outro valor dynamic , mesmo se o subobjeto tiver um tipo subjacente diferente. Use a função gettype para descobrir o tipo subjacente real do valor e qualquer uma das funções de cast listadas abaixo para efetuar cast dele para o tipo real.

Lançando objetos dinâmicos

Após assinar um objeto dinâmico, você deve converter o valor em um tipo simples.

As funções cast são:

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

Construindo objetos dinâmicos

Várias funções permitem criar novos objetos dynamic :

• zip () pares de valores "paralelos" de duas matrizes em uma matriz única.

Além disso, há várias funções agregadas que criam matrizes dynamic para manter valores agregados:

• make_list () retorna uma matriz que mantém todos os valores, em sequência
• make_list_if () retorna uma matriz contendo todos os valores, em sequência (com um predicado).
• make_list_with_nulls () retorna uma matriz contendo todos os valores, em sequência, incluindo valores nulos.
• make_set () retorna uma matriz contendo todos os valores exclusivos.
• make_set_if () retorna uma matriz contendo todos os valores exclusivos (com um predicado).

Operadores e funções sobre tipos dinâmicos

Para obter uma lista completa de funções dinâmicas / de matriz escalares, consulte funções dinâmicas / de matriz.

Indexação para dados dinâmicos

Cada campo é indexado durante a ingestão de dados O escopo do índice é um único shard de dados

Para indexar colunas dinâmicas, o processo de ingestão enumera todos os elementos "atômicos" no valor dinâmico (nomes de propriedades, valores, elementos de matriz) e os encaminha para o construtor de índice. Caso contrário, os campos dinâmicos terão o mesmo índice de termo invertido que os campos de cadeia.