Operatore mv-applymv-apply operator

Applica una sottoquery a ogni record e restituisce l'Unione dei risultati di tutte le sottoquery.Applies a subquery to each record, and returns the union of the results of all subqueries.

Si supponga, ad esempio, che una tabella includa T una colonna Metric di tipo dynamic i cui valori sono matrici di real numeri.For example, assume a table T has a column Metric of type dynamic whose values are arrays of real numbers. Nella query seguente vengono individuati i due valori principali in ogni Metric valore e vengono restituiti i record corrispondenti a tali valori.The following query will locate the two biggest values in each Metric value, and return the records corresponding to these values.

T | mv-apply Metric to typeof(real) on 
(
   top 2 by Metric desc
)

L' mv-apply operatore ha i seguenti passaggi di elaborazione:The mv-apply operator has the following processing steps:

  1. Usa l' mv-expand operatore per espandere ogni record nell'input nelle sottotabelle.Uses the mv-expand operator to expand each record in the input into subtables.
  2. Applica la sottoquery per ciascuna delle sottotabelle.Applies the subquery for each of the subtables.
  3. Aggiunge zero o più colonne alla sottotabella risultante.Adds zero or more columns to the resulting subtable. Queste colonne contengono i valori delle colonne di origine che non sono espanse e vengono ripetute laddove necessario.These columns contain the values of the source columns that aren't expanded, and are repeated where needed.
  4. Restituisce l'Unione dei risultati.Returns the union of the results.

L' mv-apply operatore ottiene gli input seguenti:The mv-apply operator gets the following inputs:

  1. Una o più espressioni che restituiscono matrici dinamiche per espandersi.One or more expressions that evaluate into dynamic arrays to expand. Il numero di record in ogni sottotabella espansa è la lunghezza massima di ogni matrice dinamica.The number of records in each expanded subtable is the maximum length of each of those dynamic arrays. Vengono aggiunti valori null in cui vengono specificate più espressioni e le matrici corrispondenti hanno lunghezze diverse.Null values are added where multiple expressions are specified and the corresponding arrays have different lengths.

  2. Facoltativamente, i nomi per assegnare i valori delle espressioni dopo l'espansione.Optionally, the names to assign the values of the expressions after expansion. Questi nomi diventano i nomi delle colonne nelle sottotabelle.These names become the columns names in the subtables. Se non specificato, il nome originale della colonna viene utilizzato quando l'espressione è un riferimento a colonna.If not specified, the original name of the column is used when the expression is a column reference. In caso contrario, viene usato un nome casuale.A random name is used otherwise.

    Nota

    È consigliabile utilizzare i nomi di colonna predefiniti.It is recommended to use the default column names.

  3. Tipi di dati degli elementi delle matrici dinamiche, dopo l'espansione.The data types of the elements of those dynamic arrays, after expansion. Questi diventano i tipi di colonna delle colonne nelle sottotabelle.These become the column types of the columns in the subtables. Se omesso, viene utilizzato dynamic.If not specified, dynamic is used.

  4. Facoltativamente, il nome di una colonna da aggiungere alle sottotabelle che specifica l'indice in base zero dell'elemento nella matrice che ha generato il record della sottotabella.Optionally, the name of a column to add to the subtables that specifies the 0-based index of the element in the array that resulted in the subtable record.

  5. Facoltativamente, il numero massimo di elementi di matrice da espandere.Optionally, the maximum number of array elements to expand.

L' mv-apply operatore può essere considerato come una generalizzazione dell' mv-expand operatore (in effetti, quest'ultimo può essere implementato dal primo, se la sottoquery include solo le proiezioni).The mv-apply operator can be thought of as a generalization of the mv-expand operator (in fact, the latter can be implemented by the former, if the subquery includes only projections.)

SintassiSyntax

T | mv-apply [ItemIndex] ColumnsToExpand [RowLimit] on ( sottoquery)T | mv-apply [ItemIndex] ColumnsToExpand [RowLimit] on ( SubQuery )

Dove ItemIndex ha la sintassi:Where ItemIndex has the syntax:

with_itemindex``= IndexColumnNamewith_itemindex = IndexColumnName

ColumnsToExpand è un elenco delimitato da virgole di uno o più elementi nel formato:ColumnsToExpand is a comma-separated list of one or more elements of the form:

[Nome = ] ArrayExpression [ to typeof ( typeName ) ][Name =] ArrayExpression [to typeof (Typename)]

RowLimit è semplicemente:RowLimit is simply:

limitRowLimitlimit RowLimit

e la sottoquery ha la stessa sintassi di qualsiasi istruzione di query.and SubQuery has the same syntax of any query statement.

ArgomentiArguments

  • ItemIndex: se usato, indica il nome di una colonna di tipo long aggiunta all'input come parte della fase di espansione della matrice e indica l'indice della matrice in base 0 del valore espanso.ItemIndex: If used, indicates the name of a column of type long that is appended to the input as part of the array-expansion phase and indicates the 0-based array index of the expanded value.

  • Nome: se usato, il nome per assegnare i valori espansi della matrice di ogni espressione espansa della matrice.Name: If used, the name to assign the array-expanded values of each array-expanded expression. Se non specificato, verrà utilizzato il nome della colonna, se disponibile.If not specified, the name of the column will be used if available. Se ArrayExpression non è un nome di colonna semplice, viene generato un nome casuale.A random name is generated if ArrayExpression is not a simple column name.

  • ArrayExpression: espressione di tipo dynamic i cui valori verranno espansi in una matrice.ArrayExpression: An expression of type dynamic whose values will be array-expanded. Se l'espressione è il nome di una colonna nell'input, la colonna di input viene rimossa dall'input e una nuova colonna con lo stesso nome, o ColumnName , se specificato, viene visualizzata nell'output.If the expression is the name of a column in the input, the input column is removed from the input and a new column of the same name (or ColumnName if specified) appears in the output.

  • TypeName: se usato, il nome del tipo che i singoli elementi della dynamic matrice ArrayExpression accettano.Typename: If used, the name of the type that the individual elements of the dynamic array ArrayExpression take. Gli elementi che non sono conformi a questo tipo verranno sostituiti da un valore null.Elements that do not conform to this type will be replaced by a null value. (Se non specificato, dynamic viene usato per impostazione predefinita).(If unspecified, dynamic is used by default.)

  • RowLimit: se usato, è previsto un limite per il numero di record da generare da ogni record dell'input.RowLimit: If used, a limit on the number of records to generate from each record of the input. Se non è specificato, viene usato 2147483647.(If unspecified, 2147483647 is used.)

  • Sottoquery: espressione di query tabulare con un'origine tabulare implicita che viene applicata a ogni sottotabella espansa di matrici.SubQuery: A tabular query expression with an implicit tabular source that gets applied to each array-expanded subtable.

NoteNotes

  • A differenza dell' mv-expand operatore, l' mv-apply operatore supporta solo l'espansione della matrice.Unlike the mv-expand operator, the mv-apply operator supports array expansion only. Non è disponibile alcun supporto per l'espansione di contenitori di proprietà.There's no support for expanding property bags.

EsempiExamples

Recupero dell'elemento più grande dalla matriceGetting the largest element from the array

let _data =
range x from 1 to 8 step 1
| summarize l=make_list(x) by xMod2 = x % 2;
_data
| mv-apply element=l to typeof(long) on 
(
   top 1 by element
)
xMod2 ll elementelement
11 [1, 3, 5, 7][1, 3, 5, 7] 77
00 [2, 4, 6, 8][2, 4, 6, 8] 88

Calcolo della somma dei due elementi più grandi in una matriceCalculating the sum of the largest two elements in an array

let _data =
range x from 1 to 8 step 1
| summarize l=make_list(x) by xMod2 = x % 2;
_data
| mv-apply l to typeof(long) on
(
   top 2 by l
   | summarize SumOfTop2=sum(l)
)
xMod2 ll SumOfTop2SumOfTop2
11 [1, 3, 5, 7][1,3,5,7] 1212
00 [2, 4, 6, 8][2,4,6,8] 1414

Utilizzo di with_itemindex per l'utilizzo di un subset della matriceUsing with_itemindex for working with a subset of the array

let _data =
range x from 1 to 10 step 1
| summarize l=make_list(x) by xMod2 = x % 2;
_data
| mv-apply with_itemindex=index element=l to typeof(long) on 
(
   // here you have 'index' column
   where index >= 3
)
| project index, element
indexindex elementelement
33 77
44 99
33 88
44 1010

Utilizzo dell' mv-apply operatore per ordinare l'output di make_list aggregazione mediante una chiaveUsing the mv-apply operator to sort the output of make_list aggregate by some key

datatable(command:string, command_time:datetime, user_id:string)
[
    'chmod',        datetime(2019-07-15),   "user1",
    'ls',           datetime(2019-07-02),   "user1",
    'dir',          datetime(2019-07-22),   "user1",
    'mkdir',        datetime(2019-07-14),   "user1",
    'rm',           datetime(2019-07-27),   "user1",
    'pwd',          datetime(2019-07-25),   "user1",
    'rm',           datetime(2019-07-23),   "user2",
    'pwd',          datetime(2019-07-25),   "user2",
]
| summarize commands_details = make_list(pack('command', command, 'command_time', command_time)) by user_id
| mv-apply command_details = commands_details on
(
    order by todatetime(command_details['command_time']) asc
    | summarize make_list(tostring(command_details['command']))
)
| project-away commands_details
user_id list_command_details_command
user1user1 [[
"ls","ls",
"mkdir","mkdir",
"chmod","chmod",
"dir","dir",
"pwd","pwd",
RM"rm"
]]
user2user2 [[
"RM","rm",
pwd"pwd"
]]

Vedere ancheSee also