SUMMARIZECOLUMNS

Si applica a:colonna calcolatatabella calcolataMeasurecalcolo visivo

Restituisce una tabella di riepilogo su un set di gruppi.

Sintassi

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

Parametri

Restituisce value

Tabella che include combinazioni di values dalle colonne fornite in base al raggruppamento specificato. Nella tabella restituita vengono incluse solo le righe per le quali almeno una delle espressioni fornite restituisce unblankvalue non. If all espressioni evaluate a BLANK/NULL per una riga, tale riga viene not inclusa nella tabella restituita.

Osservazioni:

• Questa funzione not garantisce qualsiasi 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 è not supportata per l'uso in modalità DirectQuery quando viene usata nelle colonne calcolate or regole di sicurezza a livello di riga.

contesto di Filter

Si consideri la query seguente:

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

In questa query, senza un measure le colonne groupBynot contengono colonne dell'espressione FILTER, ad esempio dalla tabella Customer. Il filter viene not applicato alle colonne di groupBy. Le tabelle Sales Territory and Customer possono essere indirettamente related tramite la tabella Reseller sales fact. Poiché sono not direttamente related, l'espressione filter è un no-op and le colonne groupBy sono not 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 filterand che filter viene applicata ai risultati 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 all espressioni not utilizzando IGNORE restituire BLANK/NULL verranno escluse indipendentemente dal fatto che le espressioni che usano IGNOREevaluate per BLANK/NULL ornot. IGNORE può essere usato solo all'interno di un'espressione SUMMARIZECOLUMNS.

Esempio

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

Verrà eseguito il rollup della colonna Sales[CustomerId], creando un subtotale per all clienti nel raggruppamento specificato. Senza IGNORE, il risultato è:

Con IGNORE,

All'espressione ignorata,

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

Even anche se entrambe le espressioni restituiscono blank per alcune righe, vengono incluse poiché non sono presenti espressioni non allineate che restituiscono blank.

Con NONVISUAL

La funzione NONVISUAL contrassegna un valuefilter nella funzione SUMMARIZECOLUMNS come not che influisce su measurevalues, ma si applica solo alle colonne groupBy. NONVISUAL può essere usato 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 tra all anni:

Al contrario, la stessa query senza funzione di 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 di ROLLUPADDISSUBTOTAL modifica il comportamento della funzione SUMMARIZECOLUMNS aggiungendo rolluprighe /subtotali al risultato in base alle colonne groupBy_columnName. ROLLUPADDISSUBTOTAL può essere usato 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 sono raggruppate per stato, per cliente, per date, con subtotali per 1. Vendite per stato, per date 2. Vendite per stato, per cliente 3. Rollup su entrambi i anddate cliente che portano alle vendite in base allo stato.

Restituisce la tabella seguente:

Con ROLLUPGROUP

Analogamente alla funzione SUMMARIZE, è possibile usare ROLLUPGROUP insieme a ROLLUPADDISSUBTOTAL per specificare quali gruppi di riepilogo/granularità (subtotali) includere, riducendo il numero di righe subtotali restituite. ROLLUPGROUP può essere usato solo all'interno di un'espressione SUMMARIZECOLUMNSorSUMMARIZE.

Esempio con più subtotali

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

Ancora raggruppati per City and State, ma distribuiti insieme quando si segnala un subtotale restituisce la tabella seguente,

SummarizeColumns contestuali

Background

Fino a febbraio 2023, SUMMARIZECOLUMNS ha not supportato la valutazione all'interno di una transizione di contesto in all. Nei prodotti rilasciati prima di tale month, questa limitazione ha reso utile SUMMARIZECOLUMNSnot nella maggior parte delle misure: è stato not possibile chiamare un measureSUMMARIZECOLUMNS in qualsiasi caso di transizione del contesto, incluso altri SUMMARIZECOLUMNSstatements.

A partire da febbraio 2023, la transizione del contesto è stata supportata in alcuni scenari, ma not in all le condizioni. I casi supportati and con restrizioni sono i seguenti:

A partire da giugno 2024, l'SummarizeColumns contestuale consente di valutare SummarizeColumns in qualsiasi transizione di contesto, SummarizeColumns in measure è now completamente supportato:

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

Semantica selfvalue per i filters esterni

Viene introdotto un concetto semantico denominato SelfValue, che modifica il modo in cui filters da tabelle esterne interagiscono con le colonne GroupBy in SummarizeColumns. Questa modifica non consente filters da una tabella diversa per influire sulle colonne GroupBy, evenif le tabelle vengono related tramite una relazione filter-by. 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 TreatAsfilter si applica all'operazione di GroupBy all'interno di SummarizeColumns, sfruttando la relazione tra "Product"[Product Key] and "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, GroupBy colonne all'interno di SummarizeColumns non verranno più filtrate in base a colonne da tabelle esterne, evenif esiste una relazione tra di esse. Nell'esempio precedente, pertanto, la colonna GroupBy 'Reseller Sales'[ProductKey] not essere filtrata in base alla colonna 'Product'[ProductKey]. Di conseguenza, la query includerà righe in cui 'Reseller Sales'[ProductKey] è not uguale a 229.

If si preferisce mantenere il comportamento di previous, è possibile riscrivere l'espressione usando Summarize anziché SummarizeColumns, come illustrato di seguito:

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

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

Convalida delle righe per groupby colonne completamente coperte da Treatas

Prima di questo aggiornamento, all'interno di una funzione SummarizeColumns, ifallGroupBy colonne di una tabella specifica erano completamente coperte da una singola Treatasfilter 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 nella Treatasfilter, indipendentemente dal fatto che siano valide ornot. Ad esempio, il risultato sarebbe una tabella a riga singola ("Stati Uniti", "Alberta"), evenif nessuna riga di questo tipo con [Country] = "Stati Uniti" and [State] = "Alberta" esiste nella tabella 'Geography'.

Questo problema è stato noto and è stato risolto dall'aggiornamento. Dopo l'aggiornamento, tali righe non valide verranno filtrate, and verranno restituite solo le righe valide della tabella GroupBy. Di conseguenza, il risultato della query precedente sarebbe vuoto, perché nella tabella 'Geography' non sono presenti righe valide corrispondenti al [Country] specificato and [State] values.

Non consentire Keepfiltersmisti /overriddefilters nella stessa tabella/cluster

L'aggiornamento recente ha introdotto una restrizione temporanea che attiva un messaggio di error 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 error si verifica quando entrambe le filters normali (che eseguono l'override di filtersesistenti ) andfilters con KeepFilters specificate 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 presenti due filters nella tabella 'Geography': una con KeepFilters specificata and senza. Queste filters si sovrappongono a filters esterne su colonne diverse. Attualmente, questa configurazione è not consentita perché internamente, le due filters vengono raggruppate in una, and il sistema non è in grado di determinare il comportamento di override corretto filter per l'filter cluster in questi casi.

Si noti che questa restrizione è temporanea. Stiamo sviluppando attivamente soluzioni per rimuovere questa limitazione negli aggiornamenti futuri. If questo error, è consigliabile modificare il filters all'interno di SummarizeColumns aggiungendo or rimuovendo KeepFilters in base alle esigenze per garantire un comportamento di override coerente in ogni tabella.

Related contenuto

SUMMARIZE