Operatore mv-expandmv-expand operator

Espande la matrice multivalore o il contenitore delle proprietà.Expands multi-value array or property bag.

mv-expand viene applicato a una matrice tipizzata dinamicao a una colonna del contenitore delle proprietà in modo che ogni valore nella raccolta ottenga una riga distinta.mv-expand is applied on a dynamic-typed array or property bag column so that each value in the collection gets a separate row. Tutte le altre colonne in una riga espansa vengono duplicate.All the other columns in an expanded row are duplicated.

SintassiSyntax

T | mv-expand [ bagexpansion= ( bag | array )] [ with_itemindex= IndexColumnName] ColumnName [ , ColumnName ...] [ limit RowLimit]T | mv-expand [bagexpansion=(bag | array)] [with_itemindex=IndexColumnName] ColumnName [, ColumnName ...] [limit Rowlimit]

T | mv-expand [ bagexpansion= ( bag | array )] [nome = ] ArrayExpression [ to typeof( typeName ) ] [, [nome = ] ArrayExpression [ to typeof( typeName ) ]...] [ limit RowLimit]T | mv-expand [bagexpansion=(bag | array)] [Name =] ArrayExpression [to typeof(Typename)] [, [Name =] ArrayExpression [to typeof(Typename)] ...] [limit Rowlimit]

ArgomentiArguments

  • ColumnName: nel risultato le matrici nella colonna denominata vengono espanse su più righe.ColumnName: In the result, arrays in the named column are expanded to multiple rows.

  • ArrayExpression: espressione che supporta una matrice.ArrayExpression: An expression yielding an array. Se viene usato questo formato, viene aggiunta una nuova colonna e quella esistente viene mantenuta.If this form is used, a new column is added and the existing one is preserved.

  • Name: nome della nuova colonna.Name: A name for the new column.

  • TypeName: Indica il tipo sottostante degli elementi della matrice, che diventa il tipo della colonna prodotta dall' mv-apply operatore.Typename: Indicates the underlying type of the array's elements, which becomes the type of the column produced by the mv-apply operator. L'operazione di applicazione del tipo è di sola cast e non include l'analisi o la conversione dei tipi.The operation of applying type is cast-only and doesn't include parsing or type-conversion. Gli elementi della matrice che non sono conformi al tipo dichiarato diventeranno null valori.Array elements that do not conform with the declared type will become null values.

  • RowLimit: numero massimo di righe generate da ogni riga originale.RowLimit: The maximum number of rows generated from each original row. Il valore predefinito è 2147483647.The default is 2147483647.

    Nota

    Il formato legacy e obsoleto dell'operatore mvexpand ha un limite di righe predefinito di 128.The legacy and obsolete form of the operator mvexpand has a default row limit of 128.

  • IndexColumnName: Se with_itemindex si specifica, l'output includerà una colonna aggiuntiva (denominata IndexColumnName), che contiene l'indice (a partire da 0) dell'elemento nella raccolta espansa originale.IndexColumnName: If with_itemindex is specified, the output will include an additional column (named IndexColumnName), which contains the index (starting at 0) of the item in the original expanded collection.

RestituisceReturns

Più righe per ogni valore in una matrice presente nella colonna denominata o nell'espressione di matrice.Multiple rows for each of the values in any array that are in the named column or in the array expression. Se vengono specificate più colonne o espressioni, queste vengono espanse in parallelo.If several columns or expressions are specified, they're expanded in parallel. Per ogni riga di input, saranno presenti altrettante righe di output di quanti sono gli elementi nell'espressione espansa più estesa (gli elenchi più brevi vengono riempiti con valori null).For each input row, there will be as many output rows as there are elements in the longest expanded expression (shorter lists are padded with nulls). Se il valore in una riga è una matrice vuota, la riga si espande in Nothing (non verrà visualizzata nel set di risultati).If the value in a row is an empty array, the row expands to nothing (won't show in the result set). Tuttavia, se il valore in una riga non è una matrice, la riga viene mantenuta nel set di risultati.However, if the value in a row isn't an array, the row is kept as is in the result set.

La colonna espansa ha sempre il tipo dinamico.The expanded column always has dynamic type. Usare un cast come todatetime() o tolong() per calcolare o aggregare i valori.Use a cast such as todatetime() or tolong() if you want to compute or aggregate values.

Sono supportate due modalità di espansione dei contenitori delle proprietà:Two modes of property-bag expansions are supported:

  • bagexpansion=bag: i contenitori delle proprietà vengono espansi in contenitori delle proprietà a voce singola.bagexpansion=bag: Property bags are expanded into single-entry property bags. Questa modalità è l'espansione predefinita.This mode is the default expansion.
  • bagexpansion=array: I contenitori delle proprietà vengono espansi in [ key , value ] strutture di matrici di valori di chiave a due elementi, consentendo l'accesso uniforme alle chiavi e ai valori, ad esempio l'esecuzione di un'aggregazione Distinct Count sui nomi di proprietà.bagexpansion=array: Property bags are expanded into two-element [key,value] array structures, allowing uniform access to keys and values (also, for example, running a distinct-count aggregation over property names).

EsempiExamples

Colonna singolaSingle Column

Semplice espansione di una singola colonna:A simple expansion of a single column:

datatable (a:int, b:dynamic)[1,dynamic({"prop1":"a", "prop2":"b"})]
| mv-expand b 
aa bb
11 {"Prop1": "a"}{"prop1":"a"}
11 {"prop2": "b"}{"prop2":"b"}

Due colonne compresseZipped two columns

Espandendo due colonne verrà prima "compresso" le colonne applicabili e quindi le si espanderanno:Expanding two columns will first 'zip' the applicable columns and then expand them:

datatable (a:int, b:dynamic, c:dynamic)[1,dynamic({"prop1":"a", "prop2":"b"}), dynamic([5, 4, 3])]
| mv-expand b, c
aa bb cc
11 {"Prop1": "a"}{"prop1":"a"} 55
11 {"prop2": "b"}{"prop2":"b"} 44
11 33

Prodotto cartesiano di due colonneCartesian product of two columns

Se si desidera ottenere un prodotto cartesiano per espandere due colonne, espanderne una dopo l'altra:If you want to get a Cartesian product of expanding two columns, expand one after the other:

datatable (a:int, b:dynamic, c:dynamic)
  [
  1,
  dynamic({"prop1":"a", "prop2":"b"}),
  dynamic([5, 6])
  ]
| mv-expand b
| mv-expand c
aa bb cc
11 {"Prop1": "a"}{ "prop1": "a"} 55
11 {"Prop1": "a"}{ "prop1": "a"} 66
11 {"prop2": "b"}{ "prop2": "b"} 55
11 {"prop2": "b"}{ "prop2": "b"} 66

Conversione dell'outputConvert output

Se si vuole forzare l'output di un MV-Expand su un determinato tipo (il valore predefinito è dinamico), usare to typeof :If you want to force the output of an mv-expand to a certain type (default is dynamic), use to typeof:

datatable (a:string, b:dynamic, c:dynamic)["Constant", dynamic([1,2,3,4]), dynamic([6,7,8,9])]
| mv-expand b, c to typeof(int)
| getschema 
ColumnNameColumnName ColumnOrdinalColumnOrdinal DateTypeDateType ColumnTypeColumnType
aa 00 System.StringSystem.String stringstring
bb 11 System.ObjectSystem.Object dinamicodynamic
cc 22 System.Int32System.Int32 INTint

La colonna b di avviso è stata rilevata come dynamic se c venisse int .Notice column b is coming out as dynamic while c is coming out as int.

Utilizzo di with_itemindexUsing with_itemindex

Espansione di una matrice con with_itemindex :Expansion of an array with with_itemindex:

range x from 1 to 4 step 1
| summarize x = make_list(x)
| mv-expand with_itemindex=Index x
xx IndiceIndex
11 00
22 11
33 22
44 33

Vedere ancheSee also