SUMMARIZECOLUMNS

Si applica a: Calcolo visivo misura tabella calcolata colonna calcolata

Restituisce una tabella di riepilogo su un set di gruppi.

Sintassi

SUMMARIZECOLUMNS( <groupBy_columnName> [, < groupBy_columnName >]…, [<filterTable>]…[, <name>, <expression>]…)  

Parametri

Valore restituito

Tabella che include combinazioni di valori dalle colonne specificate, in base al raggruppamento specificato. Nella tabella restituita vengono incluse solo le righe per le quali almeno una delle espressioni specificate restituisce un valore non vuoto. Se tutte le espressioni restituiscono BLANK/NULL per una riga, tale riga non verrà inclusa nella tabella restituita.

Osservazioni:

• Questa funzione non garantisce alcun ordinamento per i risultati.

• Una colonna non può essere specificata più di una volta nel parametro groupBy_columnName. La formula seguente, ad esempio, non è valida.

  SUMMARIZECOLUMNS( Sales[StoreId], Sales[StoreId] )

• Questa funzione non è supportata per l'uso nella modalità DirectQuery se usata in colonne calcolate o nelle regole di sicurezza a livello di riga.

Contesto di filtro

Si consideri la query seguente:

SUMMARIZECOLUMNS ( 
    'Sales Territory'[Category], 
    FILTER('Customer', 'Customer' [First Name] = "Alicia") 
)

In questa query senza una misura le colonne groupBy non contengono colonne dell'espressione FILTER (ad esempio, della tabella Customer). Il filtro non viene applicato alle colonne groupBy. Le tabelle Sales Territory e Customer possono essere indirettamente correlate tramite la tabella dei fatti Reseller sales. Poiché non sono correlate direttamente, l'espressione filtro non prevede alcuna operazione e le colonne groupBy non sono interessate.

Tuttavia con questa query:

SUMMARIZECOLUMNS ( 
    'Sales Territory'[Category], 'Customer' [Education], 
    FILTER('Customer', 'Customer'[First Name] = "Alicia") 
)

Le colonne groupBy contengono una colonna interessata dal filtro e tale filtro viene applicato ai risultati di groupBy.

Con IGNORE

La sintassi IGNORE può essere usata per modificare il comportamento della funzione SUMMARIZECOLUMNS omettendo espressioni specifiche dalla valutazione BLANK/NULL. Le righe per le quali tutte le espressioni che non usano IGNORE restituiscono BLANK/NULL verranno escluse, indipendentemente dal fatto che le espressioni che usano IGNORE restituiscano o meno BLANK/NULL. La funzione IGNORE può essere usata solo all'interno di un'espressione SUMMARIZECOLUMNS.

Esempio

SUMMARIZECOLUMNS( 
    Sales[CustomerId], "Total Qty", 
    IGNORE( SUM( Sales[Qty] ) ), 
    "BlankIfTotalQtyIsNot3", IF( SUM( Sales[Qty] )=3, 3 ) 
)

Esegue il rollup della colonna Sales[CustomerId], creando un subtotale per tutti i clienti nel raggruppamento specificato. Senza IGNORE, il risultato è:

Con IGNORE,

Tutte le espressioni ignorate,

SUMMARIZECOLUMNS( 
    Sales[CustomerId], "Blank", 
    IGNORE( BLANK() ), "BlankIfTotalQtyIsNot5", 
    IGNORE( IF( SUM( Sales[Qty] )=5, 5 ) ) 
)

Anche se entrambe le espressioni restituiscono BLANK per alcune righe, vengono incluse perché non sono presenti espressioni non ignorate che restituiscono BLANK.

Con NONVISUAL

La funzione NONVISUAL indica che un filtro di valore nella funzione SUMMARIZECOLUMNS non influisce sui valori di misura, ma si applica solo alle colonne groupBy. La funzione NONVISUAL può essere usata solo all'interno di un'espressione SUMMARIZECOLUMNS.

Esempio

DEFINE
MEASURE FactInternetSales[Sales] = SUM(FactInternetSales[Sales Amount])
EVALUATE
SUMMARIZECOLUMNS
(
    DimDate[CalendarYear],
    NONVISUAL(TREATAS({2007, 2008}, DimDate[CalendarYear])),
    "Sales", [Sales],
    "Visual Total Sales", CALCULATE([Sales], ALLSELECTED(DimDate[CalendarYear]))
)
ORDER BY [CalendarYear]

Restituisce il risultato in cui [Visual Total Sales] è il totale per tutti gli anni:

Al contrario, la stessa query senza la funzione NONVISUAL:

DEFINE
MEASURE FactInternetSales[Sales] = SUM(FactInternetSales[Sales Amount])
EVALUATE
SUMMARIZECOLUMNS
(
    DimDate[CalendarYear],
    TREATAS({2007, 2008}, DimDate[CalendarYear]),
    "Sales", [Sales],
    "Visual Total Sales", CALCULATE([Sales], ALLSELECTED(DimDate[CalendarYear]))
)
ORDER BY [CalendarYear]

Restituisce il risultato in cui [Visual Total Sales] è il totale per i due anni selezionati:

Con ROLLUPADDISSUBTOTAL

L'aggiunta della sintassi ROLLUPADDISSUBTOTAL modifica il comportamento della funzione SUMMARIZECOLUMNS aggiungendo righe di rollup/subtotali al risultato in base alle colonne groupBy_columnName. La funzione ROLLUPADDISSUBTOTAL può essere usata solo all'interno di un'espressione SUMMARIZECOLUMNS.

Esempio con singolo subtotale

DEFINE
VAR vCategoryFilter =
  TREATAS({"Accessories", "Clothing"}, Product[Category])
VAR vSubcategoryFilter = 
  TREATAS({"Bike Racks", "Mountain Bikes"}, Product[Subcategory])
EVALUATE
  SUMMARIZECOLUMNS
  (
    ROLLUPADDISSUBTOTAL
    (
      Product[Category], "IsCategorySubtotal", vCategoryFilter,
      Product[Subcategory], "IsSubcategorySubtotal", vSubcategoryFilter
    ),
    "Total Qty", SUM(Sales[Qty])
  )
  ORDER BY
  [IsCategorySubtotal] DESC, [Category],
  [IsSubcategorySubtotal] DESC, [Subcategory]

Restituisce la tabella seguente:

Esempio con più subtotali

SUMMARIZECOLUMNS ( 
    Regions[State], ROLLUPADDISSUBTOTAL ( Sales[CustomerId], "IsCustomerSubtotal" ), 
    ROLLUPADDISSUBTOTAL ( Sales[Date], "IsDateSubtotal"), "Total Qty", SUM( Sales[Qty] ) 
)

Le vendite vengono raggruppate per stato, per cliente, per data, con subtotali per 1. Vendite per stato, per data 2. Vendite per stato, per cliente 3. Il rollup viene eseguito sia per cliente che per data, ottenendo le vendite per stato.

Restituisce la tabella seguente:

Con ROLLUPGROUP

Analogamente alla funzione SUMMARIZE, è possibile usare ROLLUPGROUP con ROLLUPADDISSUBTOTAL per specificare quali gruppi di riepilogo/granularità (subtotali) includere (riducendo il numero di righe di subtotale restituite). La funzione ROLLUPGROUP può essere usata solo all'interno di un'espressione SUMMARIZECOLUMNS o SUMMARIZE.

Esempio con più subtotali

SUMMARIZECOLUMNS( 
    ROLLUPADDISSUBTOTAL( Sales[CustomerId], "IsCustomerSubtotal" ), 
    ROLLUPADDISSUBTOTAL(ROLLUPGROUP(Regions[City], Regions[State]), "IsCityStateSubtotal"),"Total Qty", SUM( Sales[Qty] ) 
)

Ancora raggruppati per città e stato, ma sommati insieme quando si indica un subtotale, viene restituita la tabella seguente.

Riepilogo contestualeColumns

Background

Fino a febbraio 2023, SUMMARIZECOLUMNS non supportava affatto la valutazione all'interno di una transizione di contesto. Nei prodotti rilasciati prima di quel mese, questa limitazione ha reso SUMMARIZECOLUMNS non utile nella maggior parte delle misure. Non è stato possibile chiamare una misura SUMMARIZECOLUMNS in alcun caso di transizione del contesto, incluse altre istruzioni SUMMARIZECOLUMNS.

A partire da febbraio 2023, la transizione del contesto è stata supportata in alcuni scenari, ma non in tutte le condizioni. I casi supportati e limitati sono i seguenti:

A partire da giugno 2024, è possibile abilitare SummarizeColumns contestuale che consente di valutare SummarizeColumns in qualsiasi transizione di contesto, SummarizeColumns nella misura è ora completamente supportato:

Tuttavia, questo aggiornamento include anche modifiche al comportamento di SummarizeColumns, che può modificare i risultati delle espressioni esistenti:

Semantica SelfValue per i filtri esterni

Viene introdotto un concetto semantico denominato SelfValue, che modifica il modo in cui i filtri delle tabelle esterne interagiscono con le colonne GroupBy in SummarizeColumns. Questa modifica impedisce i filtri di una tabella diversa per influire sulle colonne GroupBy, anche se le tabelle sono correlate tramite una relazione di filtro per. Un esempio che illustra l'impatto di questa modifica comporta l'espressione seguente:

CalculateTable(
  SummarizeColumns(
      'Reseller Sales'[ResellerKey], 
      'Reseller Sales'[ProductKey]
  ), 
  Treatas({(229)}, 'Product'[Product Key])
)

Prima di questo aggiornamento, il filtro TreatAs verrà applicato all'operazione GroupBy all'interno di SummarizeColumns, sfruttando la relazione tra 'Product'[Product Key] e 'Reseller Sales'[ProductKey]. Di conseguenza, i risultati della query includono solo le righe in cui 'Reseller Sales'[ProductKey] è uguale a 229. Tuttavia, dopo l'aggiornamento, le colonne GroupBy all'interno di SummarizeColumns non verranno più filtrate in base alle colonne da tabelle esterne, anche se esiste una relazione tra di esse. Pertanto, nell'esempio precedente la colonna GroupBy 'Reseller Sales'[ProductKey] non verrà filtrata in base alla colonna 'Product'[ProductKey]. Di conseguenza, la query includerà righe in cui 'Reseller Sales'[ProductKey] non è uguale a 229.

Se si preferisce mantenere il comportamento precedente, è possibile riscrivere l'espressione usando AddColumns o SelectColumns anziché SummarizeColumns, come illustrato di seguito:

CalculateTable(
    Filter(
        SelectColumns(
            'Reseller Sales',
            "ResellerKey", 
            [ResellerKey],
            "ProductKey",
            [ProductKey]
        ),
        And(Not IsBlank([ResellerKey]),  Not IsBlank([ProductKey]))
    ),
    Treatas({(229)}, 'Product'[Product Key])
)

Questa espressione riscritta mantiene la semantica originale in cui l'operazione GroupBy non è influenzata dalla restrizione SelfValue introdotta dall'aggiornamento.

Convalida delle righe per le colonne groupby completamente coperte da Treatas

Prima di questo aggiornamento, all'interno di una funzione SummarizeColumns, se tutte le colonne GroupBy di una tabella specifica erano completamente coperte da un singolo filtro Treatas dalla stessa tabella, come illustrato di seguito:

SummarizeColumns(
  Geography[Country], 
  Geography[State], 
  Treatas(
      {("United States", "Alberta")}, 
      Geography[Country], 
      Geography[State]
  )
)

Il risultato della query precedente include le righe specificate nel filtro Treatas, indipendentemente dal fatto che siano valide o meno. Ad esempio, il risultato sarebbe una tabella a riga singola ("Stati Uniti", "Alberta"), anche se tale riga con [Country] = "Stati Uniti" e [State] = "Alberta" esisteva nella tabella 'Geography'.

Questo problema è stato noto ed è stato risolto dall'aggiornamento. Dopo l'aggiornamento, tali righe non valide verranno filtrate e verranno restituite solo le righe valide della tabella GroupBy. Di conseguenza, il risultato della query precedente sarebbe vuoto, poiché non sono presenti righe valide corrispondenti ai valori [Country] e [State] specificati nella tabella 'Geography'.

Non consentire filtri Keepfilters/overriddefilter misti nello stesso cluster o tabella

L'aggiornamento recente ha introdotto una restrizione temporanea che attiva un messaggio di errore che indica:

"SummarizeColumns filters with keepfilters behavior and overridefilters behavior are mixed within one cluster, which is not allowed. Consider adding keepfilters() to all filters of summarizecolumns." 

Questo errore si verifica quando entrambi i filtri normali (che eseguono l'override dei filtri esistenti) e i filtri con KeepFilter specificati sono presenti all'interno della stessa tabella/cluster. Ad esempio:

Evaluate CalculateTable(
  SummarizeColumns(
      Product[Color],
      KeepFilters(
          TreatAs(
              {( "Washington")}
              , Geography[State]
          )
      ),
      TreatAs(
          {("United States"), ("Canada")}
          , Geography[Country]
      )
  )
  ,TreatAs({("Alberta")}, Geography[State])
  ,TreatAs({("Canada")}, Geography[Country])
)

Nell'espressione precedente sono disponibili due filtri per la tabella 'Geography': uno con KeepFilters specificato e uno senza. Questi filtri si sovrappongono a filtri esterni su colonne diverse. Attualmente, questa configurazione non è consentita perché internamente, i due filtri vengono raggruppati in uno e il sistema non è in grado di determinare il comportamento di override corretto del filtro per il filtro cluster in questi casi.

Si noti che questa restrizione è temporanea. Stiamo sviluppando attivamente soluzioni per rimuovere questa limitazione negli aggiornamenti futuri. Se si verifica questo errore, è consigliabile modificare i filtri all'interno di SummarizeColumns aggiungendo o rimuovendo KeepFilters in base alle esigenze per garantire un comportamento di override coerente in ogni tabella.

Contenuto correlato

SUMMARIZE