O tipo de dados dinâmico
O dynamic
tipo de dados escalar pode ser qualquer um dos seguintes valores:
- Uma matriz de
dynamic
valores com zero ou mais valores com indexação baseada em zero. - Um saco de propriedades que mapeia valores exclusivos
string
paradynamic
valores. O conjunto de propriedades tem zero ou mais desses mapeamentos (denominados "blocos"), indexados pelos valores exclusivosstring
. As ranhuras não estão ordenadas. - Um valor de qualquer um dos tipos de dados escalares primitivos:
bool
, ,guid
datetime
,int
,long
,real
,string
etimespan
. - Nulo. Para obter mais informações, veja Valores nulos.
Nota
- Os valores do tipo
dynamic
estão limitados a 1 MB (2^20), descomprimidos. Se um valor de célula num registo exceder 1 MB, o valor é removido e a ingestão é bem-sucedida. Pode aumentar aMaxValueSize
coluna ao alterar a respetiva política de codificação. - Embora o
dynamic
tipo pareça semelhante a JSON, pode conter valores que o modelo JSON não representa porque não existem em JSON (por exemplolong
, ,real
,datetime
,timespan
eguid
). Por conseguinte, ao serializardynamic
valores numa representação JSON, os valores que o JSON não pode representar são serializados emstring
valores. Por outro lado, o Kusto irá analisar cadeias como valores com tipos fortes, se puderem ser analisadas como tal. Isto aplica-se aosdatetime
tipos ,real
,long
eguid
. Para obter mais informações sobre o modelo de objeto JSON, veja json.org. - O Kusto não tenta preservar a ordem dos mapeamentos de nome para valor num saco de propriedades, pelo que não pode assumir a ordem de preservação. É totalmente possível que dois pacotes de propriedades com o mesmo conjunto de mapeamentos produzam resultados diferentes quando são representados como
string
valores, por exemplo.
Literais dinâmicos
Para especificar um dynamic
literal, utilize uma das seguintes opções de sintaxe:
Syntax | Descrição | Exemplo |
---|---|---|
dynamic([ value [, ...]]) |
Uma matriz de literais dinâmicos ou outros literais escalares. | dynamic([1, 2, "hello"]) |
dynamic({ tecla= value [, ...]}) |
Um saco de propriedades ou objeto. O valor de uma chave pode ser um saco de propriedades aninhado. | dynamic({"a":1, "b":{"a":2}}) |
dynamic( valor) |
Um valor dinâmico que contém o valor do tipo de dados escalar interno. | dynamic(4) |
dynamic(null) |
Representa o valor nulo. |
Saiba mais sobre as convenções de sintaxe.
Acessórios de objetos dinâmicos
Para inferior à linha de um dicionário, utilize a notação de pontos (dict.key
) ou a notação entre parênteses retos (dict["key"]
). Quando a linha inferior é uma constante de cadeia, ambas as opções são equivalentes.
Nota
Para utilizar uma expressão como inferior à linha, utilize a notação de parênteses retos. Ao utilizar expressões aritméticas, a expressão dentro dos parênteses tem de ser encapsulada entre parênteses.
Nos exemplos abaixo dict
e arr
são colunas do tipo dinâmico:
Expression | Tipo de expressão de acessório | Significado | Comentários |
---|---|---|---|
dict[col] | Nome da entidade (coluna) | Subscripts a dictionary using the values of the column col as the key |
A coluna tem de ser do tipo cadeia |
arr[índice] | Índice de entidades (coluna) | Subscripts an array using the values of the column index as the index |
A coluna tem de ser do tipo número inteiro ou booleano |
arr[-index] | Índice de entidades (coluna) | Obtém o valor "index"-th a partir do fim da matriz | A coluna tem de ser do tipo número inteiro ou booleano |
arr[(-1)] | Índice de entidades | Obtém o último valor na matriz | |
arr[toint(indexAsString)] | Chamada de função | Converte os valores da coluna indexAsString em int e utiliza-os para subescritar uma matriz |
|
dict[['where']] | Palavra-chave utilizada como nome da entidade (coluna) | Subscripts a dictionary using the values of column where as the key |
Os nomes de entidades idênticos a algumas palavras-chave de linguagem de consulta têm de ser citados |
dict.['where'] ou dict['where'] | Constante | Subscripts a dictionary using where string as the key |
Dica
Recomendamos a utilização de subtipos constantes sempre que possível.
O acesso a um sub-objeto de um dynamic
valor gera outro dynamic
valor, mesmo que o sub-objeto tenha um tipo subjacente diferente. Utilize a gettype
função para detetar o tipo subjacente real do valor e qualquer uma das funções de conversão listadas abaixo para a converter no tipo real.
A lançar objetos dinâmicos
Depois de subescritar um objeto dinâmico, tem de converter o valor num tipo simples.
Expression | Valor | Tipo |
---|---|---|
X | parse_json('[100,101,102]') | matriz |
X[0] | parse_json('100') | dynamic |
toint(X[1]) | 101 | int |
Y | parse_json('{"a1":100, "a b c":"2015-01-01"}') | dicionário |
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 |
As funções cast são:
tolong()
todouble()
todatetime()
totimespan()
tostring()
toguid()
parse_json()
Criar objetos dinâmicos
Várias funções permitem-lhe criar novos dynamic
objetos:
- bag_pack() cria um saco de propriedades a partir de pares nome/valor.
- pack_array() cria uma matriz a partir de pares nome/valor.
- range() cria uma matriz com uma série aritmética de números.
- zip() emparelha valores "paralelos" de duas matrizes numa única matriz.
- repeat() cria uma matriz com um valor repetido.
Além disso, existem várias funções de agregação que criam dynamic
matrizes para conter valores agregados:
- buildschema() devolve o esquema agregado de múltiplos
dynamic
valores. - make_bag() devolve um saco de propriedades de valores dinâmicos dentro do grupo.
- make_bag_if() devolve um saco de propriedades de valores dinâmicos dentro do grupo (com um predicado).
- make_list() devolve uma matriz que contém todos os valores, em sequência.
- make_list_if() devolve uma matriz que contém todos os valores, em sequência (com um predicado).
- make_list_with_nulls() devolve uma matriz que contém todos os valores, em sequência, incluindo valores nulos.
- make_set() devolve uma matriz que contém todos os valores exclusivos.
- make_set_if() devolve uma matriz que contém todos os valores exclusivos (com um predicado).
Operadores e funções sobre tipos dinâmicos
Para obter uma lista completa das funções de matriz/dinâmicas escalares, veja funções dinâmicas/de matriz.
Operador ou função | Utilização com tipos de dados dinâmicos |
---|---|
valorin matriz |
Verdadeiro se existir um elemento de matriz que == valor where City in ('London', 'Paris', 'Rome') |
valor!in matriz |
Verdadeiro se não existir nenhum elemento de matriz que == valor |
array_length( matriz) |
Nulo se não for uma matriz |
bag_has_key( chave de saco, ) |
Verifica se uma coluna de saco dinâmico contém uma determinada chave. |
bag_keys( saco) |
Enumera todas as teclas raiz num objeto dinâmico property-bag. |
bag_merge( bag1,...,bagN) |
Intercala property-bags dinâmicos num conjunto de propriedades dinâmico com todas as propriedades unidas. |
bag_set_key( saco,chave,valor) |
Define uma determinada chave para um determinado valor num pacote de propriedades dinâmico. |
extract_json (caminho,objeto), extract_json( caminho,objeto) |
Utilize o caminho para navegar para o objeto. |
parse_json( origem) |
Transforma uma cadeia JSON num objeto dinâmico. |
range( de,para,passo) |
Uma matriz de valores. |
mv-expand listColumn |
Replica uma linha para cada valor numa lista numa célula especificada. |
summarize buildschema( coluna) |
Infere o tipo de esquema do conteúdo da coluna. |
summarize make_bag( coluna) |
Intercala os valores do saco de propriedades (dicionário) na coluna num único saco de propriedades, sem duplicação de chave. |
summarize make_bag_if( coluna, predicado) |
Intercala os valores do saco de propriedades (dicionário) na coluna num único saco de propriedades, sem duplicação de chave (com predicado). |
summarize make_list( coluna) |
Aplana grupos de linhas e coloca os valores da coluna numa matriz. |
summarize make_list_if( coluna, predicado) |
Aplana grupos de linhas e coloca os valores da coluna numa matriz (com predicado). |
summarize make_list_with_nulls( coluna) |
Aplana grupos de linhas e coloca os valores da coluna numa matriz, incluindo valores nulos. |
summarize make_set( coluna) |
Aplana grupos de linhas e coloca os valores da coluna numa matriz, sem duplicação. |
Indexação de dados dinâmicos
Todos os campos são indexados durante a ingestão de dados. O âmbito do índice é uma única partição horizontal de dados.
Para indexar colunas dinâmicas, o processo de ingestão enumera todos os elementos "atómicos" dentro do valor dinâmico (nomes de propriedades, valores, elementos de matriz) e encaminha-os para o construtor de índices. Caso contrário, os campos dinâmicos têm o mesmo índice de termos invertidos que os campos de cadeia.
Exemplos
Saco de propriedades dinâmico
A consulta seguinte cria um saco de propriedades dinâmico.
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, dynamic
os literais que aparecem no texto da consulta em si também podem incluir outros literais kusto com tipos: datetime
, timespan
, , real
, long
, guid
, bool
e dynamic
.
Esta extensão através de JSON não está disponível ao analisar cadeias (por exemplo, ao utilizar a parse_json
função ou ao ingerir dados), mas permite-lhe fazer o seguinte:
print d=dynamic({"a": datetime(1970-05-11)})
Para analisar um string
valor que siga as regras de codificação JSON num dynamic
valor, utilize a parse_json
função. Por exemplo:
parse_json('[43, 21, 65]')
- uma matriz de númerosparse_json('{"name":"Alan", "age":21, "address":{"street":432,"postcode":"JLK32P"}}')
- um dicionárioparse_json('21')
- um valor único do tipo dinâmico que contém um númeroparse_json('"21"')
- um único valor do tipo dinâmico que contém uma cadeiaparse_json('{"a":123, "b":"hello", "c":[1,2,3], "d":{}}')
- dá o mesmo valor queo
no exemplo acima.
Nota
Ao contrário do JavaScript, o JSON requer a utilização de carateres de plicas ("
) em torno de cadeias e nomes de propriedades do saco de propriedades. Por conseguinte, é geralmente mais fácil citar um literal de cadeia codificada por JSON com um caráter de plica ('
).
Ingerir dados em colunas dinâmicas
O exemplo seguinte mostra como pode definir uma tabela que contém uma dynamic
coluna (bem como uma datetime
coluna) e, em seguida, ingerir um único registo na mesma. Também demonstra como pode codificar cadeias JSON em ficheiros 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!""}"]
Saída
CarimboDeDataEHora | Rastreio |
---|---|
2015-01-01 00:00:00.0000000 | {"EventType":"Demo","EventValue":"Double-quote love!"} |
Conteúdo relacionado
- Para obter um exemplo sobre como consultar com objetos dinâmicos e acessórios de objetos, veja Mapear valores de um conjunto para outro.
Comentários
https://aka.ms/ContentUserFeedback.
Brevemente: Ao longo de 2024, vamos descontinuar progressivamente o GitHub Issues como mecanismo de feedback para conteúdos e substituí-lo por um novo sistema de feedback. Para obter mais informações, veja:Submeter e ver comentários