Condividi tramite


Operatore mv-expand

Espande matrici dinamiche multivalore o contenitori di proprietà in più record.

mv-expand può essere descritto come l'opposto degli operatori di aggregazione che comprimeno più valori in una singola matrice o contenitore di proprietà tipizzato dinamico, ad esempio summarize ... make-list() e make-series. Ogni elemento nella matrice (scalare) o nel contenitore delle proprietà genera un nuovo record nell'output dell'operatore. Tutte le colonne dell'input non espanse vengono duplicate in tutti i record nell'output.

Sintassi

T|mv-expand [kind=(bagarray | )] [with_itemindex=IndexColumnName] ColumnName [to typeof(Typename)] [,ColumnName ...] [limitRowlimit]

T|mv-expand [kind=(bag | array)] [Name=] ArrayExpression [to typeof(Typename)] [, [Name=] ArrayExpression [to typeof(Typename)] ...] [limitRowlimit]

Altre informazioni sulle convenzioni di sintassi.

Parametri

Nome Tipo Obbligatoria Descrizione
ColumnName, ArrayExpression string ✔️ Riferimento a una colonna o a un'espressione scalare con un valore di tipo dynamic che contiene una matrice o un contenitore di proprietà. I singoli elementi di primo livello della matrice o del contenitore delle proprietà vengono espansi in più record.
Quando viene usato ArrayExpression e Name non è uguale a alcun nome di colonna di input, il valore espanso viene esteso in una nuova colonna nell'output. In caso contrario, l'oggetto ColumnName esistente viene sostituito.
Nome string Nome della nuova colonna.
Typename string ✔️ Indica il tipo sottostante degli elementi della matrice, che diventa il tipo della colonna prodotta dall'operatore mv-expand . L'operazione di applicazione del tipo esegue solo il cast e non include l'analisi o la conversione del tipo. Gli elementi di matrice che non sono conformi al tipo dichiarato diventano null valori.
RowLimit int Numero massimo di righe generate da ogni riga originale. Il valore predefinito è 2147483647. mvexpand è un formato legacy e obsoleto dell'operatore mv-expand. La versione legacy ha un limite di riga predefinito di 128.
IndexColumnName string Se with_itemindex viene specificato, l'output include un'altra colonna denominata IndexColumnName che contiene l'indice a partire da 0 dell'elemento nell'insieme espanso originale.

Restituisce

Per ogni record nell'input, l'operatore restituisce zero, uno o molti record nell'output, come determinato nel modo seguente:

  1. Le colonne di input non espanse vengono visualizzate nell'output con il relativo valore originale. Se un singolo record di input viene espanso in più record di output, il valore viene duplicato in tutti i record.

  2. Per ogni ColumnName o ArrayExpression espanso, il numero di record di output viene determinato per ogni valore, come illustrato nelle modalità di espansione. Per ogni record di input viene calcolato il numero massimo di record di output. Tutte le matrici o i contenitori delle proprietà vengono espansi "in parallelo" in modo che i valori mancanti (se presenti) vengano sostituiti da valori Null. Gli elementi vengono espansi in righe nell'ordine in cui vengono visualizzati nella matrice/contenitore originale.

  3. Se il valore dinamico è Null, viene generato un singolo record per tale valore (null). Se il valore dinamico è una matrice o un contenitore di proprietà vuoto, non viene generato alcun record per tale valore. In caso contrario, il numero di record generati come sono presenti elementi nel valore dinamico.

Le colonne espanse sono di tipo dynamic, a meno che non vengano digitate in modo esplicito usando la to typeof() clausola .

Modalità di espansione

Sono supportate due modalità di espansione del contenitore delle proprietà:

  • kind=bag oppure bagexpansion=bag: i contenitori di proprietà vengono espansi in contenitori di proprietà a voce singola. Questa è la modalità predefinita.
  • kind=arrayo bagexpansion=array: i contenitori delle proprietà vengono espansi instrutture di matrice di valori chiave,] a due elementi[, consentendo l'accesso uniforme a chiavi e valori. Questa modalità consente, ad esempio, di eseguire un'aggregazione distinct-count sui nomi delle proprietà.

Esempio

Singola colonna - Espansione della matrice

datatable (a: int, b: dynamic)
[
    1, dynamic([10, 20]),
    2, dynamic(['a', 'b'])
]
| mv-expand b

Output

a b
1 10
1 20
2 a
2 b

Singola colonna - Espansione del contenitore

Una semplice espansione di una colonna singola:

datatable (a: int, b: dynamic)
[
    1, dynamic({"prop1": "a1", "prop2": "b1"}),
    2, dynamic({"prop1": "a2", "prop2": "b2"})
]
| mv-expand b

Output

a b
1 {"prop1": "a1"}
1 {"prop2": "b1"}
2 {"prop1": "a2"}
2 {"prop2": "b2"}

Singola colonna - Espansione del contenitore in coppie chiave-valore

Semplice espansione del contenitore per coppie chiave-valore:

datatable (a: int, b: dynamic)
[
    1, dynamic({"prop1": "a1", "prop2": "b1"}),
    2, dynamic({"prop1": "a2", "prop2": "b2"})
]
| mv-expand kind=array b 
| extend key = b[0], val=b[1]

Output

a b Key Val
1 ["prop1","a1"] prop1 a1
1 ["prop2","b1"] prop2 b1
2 ["prop1","a2"] prop1 a2
2 ["prop2","b2"] prop2 B2

Due colonne compresse

L'espansione di due colonne comprimerà prima le colonne applicabili e quindi le espanderà:

datatable (a: int, b: dynamic, c: dynamic)[
    1, dynamic({"prop1": "a", "prop2": "b"}), dynamic([5, 4, 3])
]
| mv-expand b, c

Output

a b c
1 {"prop1":"a"} 5
1 {"prop2":"b"} 4
1 3

Prodotto cartesiano di due colonne

Per ottenere un prodotto cartesiano di due colonne, espanderle una dopo l'altra:

datatable (a: int, b: dynamic, c: dynamic)
[
    1, dynamic({"prop1": "a", "prop2": "b"}), dynamic([5, 6])
]
| mv-expand b
| mv-expand c

Output

a b c
1 { "prop1": "a"} 5
1 { "prop1": "a"} 6
1 { "prop2": "b"} 5
1 { "prop2": "b"} 6

Conversione dell'output

Per forzare l'output di un mv-expand a un determinato tipo (il valore predefinito è dinamico), usare 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 

Output

ColumnName ColumnOrdinal DateType ColumnType
a 0 System.String string
b 1 System.Object dynamic
c 2 System.Int32 int

Si noti che la colonna b viene restituita come dynamic mentre c viene restituita come int.

Uso di with_itemindex

Espansione di una matrice con with_itemindex:

range x from 1 to 4 step 1
| summarize x = make_list(x)
| mv-expand with_itemindex=Index x

Output

x Indice
1 0
2 1
3 2
4 3