SUMMARIZECOLUMNS

gäller för:beräknad kolumnberäknad tabellMeasurevisuell beräkning

Returnerar en sammanfattningstabell över en uppsättning grupper.

Syntax

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

Parametrar

Returnera value

En tabell som innehåller kombinationer av values från de angivna kolumnerna baserat på den angivna grupperingen. Endast rader för vilka minst ett av de angivna uttrycken returnerar en icke-blankvalue ingår i tabellen som returneras. If all uttryck evaluate för att BLANK/NULL för en rad tas den raden not med i den returnerade tabellen.

Kommentarer

• Den här funktionen garanterar not sorteringsordningen för resultaten.

• Det går inte att ange en kolumn mer än en gång i parametern groupBy_columnName. Följande formel är till exempel ogiltig.

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

• Den här funktionen stöds not för användning i DirectQuery-läge när den används i beräknade kolumner or regler för säkerhet på radnivå (RLS).

Filter kontext

Överväg följande fråga:

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

I den här frågan, utan en measuregroupBy kolumner innehåller not kolumner från FILTER-uttrycket (till exempel från kundtabellen). filter tillämpas not på de groupBy kolumnerna. Tabellerna Sales Territory and Customer kan indirekt related via tabellen Reseller sales fact. Eftersom de not direkt relatedär filter-uttrycket en no-op andgroupBy kolumnerna påverkas not.

Men med den här frågan:

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

De groupBy kolumnerna innehåller en kolumn som påverkas av filterand som filter tillämpas på groupBy resultat.

Med IGNORE

Syntaxen IGNORE kan användas för att ändra beteendet för funktionen SUMMARIZECOLUMNS genom att utelämna specifika uttryck från utvärderingen BLANK/NULL. Rader för vilka all uttryck not med IGNORE returnerar BLANK/NULL utesluts oberoende av om de uttryck som använder IGNOREevaluate för att BLANK/NULL ornot. IGNORE kan bara användas i ett SUMMARIZECOLUMNS uttryck.

Exempel

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

Detta samlar kolumnen Sales[CustomerId] och skapar en delsumma för all kunder i den angivna grupperingen. Utan IGNOREblir resultatet:

Med IGNORE,

All uttryck ignoreras,

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

Even även om båda uttrycken returnerar blank för vissa rader inkluderas de eftersom det inte finns några oignorerade uttryck som returnerar blank.

Med NONVISUAL

Funktionen NONVISUAL markerar en valuefilter i SUMMARIZECOLUMNS funktion som not som påverkar measurevalues, men endast gäller för groupBy kolumner. NONVISUAL kan bara användas i ett SUMMARIZECOLUMNS uttryck.

Exempel

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]

Returnerar resultatet där [Visual Total Sales] är summan under all år:

Däremot samma fråga utan funktionen 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]

Returnerar resultatet där [Visual Total Sales] är summan under de två valda åren:

Med ROLLUPADDISSUBTOTAL

Tillägget av ROLLUPADDISSUBTOTAL-syntaxen ändrar beteendet för funktionen SUMMARIZECOLUMNS genom att lägga till rollup/delsummor i resultatet baserat på de groupBy_columnName kolumnerna. ROLLUPADDISSUBTOTAL kan bara användas i ett SUMMARIZECOLUMNS uttryck.

Exempel med enkel delsumma

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]

Returnerar följande tabell,

Exempel med flera delsummor

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

Försäljningen grupperas efter delstat, efter kund, efter date, med delsummor för 1. Försäljning efter delstat, efter date 2. Försäljning efter delstat, efter kund 3. Upprullad på båda kundernas anddate vilket ledde till försäljning efter delstat.

Returnerar följande tabell,

Med ROLLUPGROUP

Precis som med funktionen SUMMARIZE kan ROLLUPGROUP användas tillsammans med ROLLUPADDISSUBTOTAL för att ange vilka sammanfattningsgrupper/kornigheter (delsummor) som ska inkluderas, vilket minskar antalet returnerade delsummor. ROLLUPGROUP kan bara användas i ett SUMMARIZECOLUMNSorSUMMARIZE uttryck.

Exempel med flera delsummor

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

Fortfarande grupperad efter City and State, men sammansatt när du rapporterar en delsumma returnerar följande tabell.

Kontextuell SummarizeColumns

Bakgrund

Fram till februari 2023 stödde SUMMARIZECOLUMNSnot utvärdering inom en kontextövergång vid all. I produkter som släpptes före den monthgjorde den här begränsningen SUMMARIZECOLUMNSnot användbar i de flesta av åtgärderna – det var not möjligt att anropa en measureSUMMARIZECOLUMNS i alla fall av kontextövergång, inklusive andra SUMMARIZECOLUMNSstatements.

Från februari 2023 stöddes kontextövergången i några scenarier, men not i all villkoren. De and begränsade ärenden som stöds är följande:

Från juni 2024 aktiverar vi kontextuella SummarizeColumns som gör att SummarizeColumns kan utvärderas i alla kontextövergångar, SummarizeColumns i measure stöds now fullt ut:

Den här uppdateringen innehåller dock även ändringar i beteendet för SummarizeColumns, vilket kan ändra resultatet av befintliga uttryck:

SelfValue-semantik för externa filters

Vi introducerar ett semantiskt begrepp med namnet SelfValue, som ändrar hur filters från externa tabeller interagerar med GroupBy kolumner i SummarizeColumns. Den här ändringen tillåter inte att filters från en annan tabell påverkar de GroupBy kolumnerna, evenif tabellerna related via en filter-by-relation. Ett exempel som illustrerar effekten av den här ändringen omfattar följande uttryck:

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

Före den här uppdateringen skulle TreatAsfilter gälla för den GroupBy åtgärden i SummarizeColumnsoch utnyttja relationen mellanProduct[Product Key] and "Reseller Sales"[ProductKey]. Därför skulle frågeresultatet bara innehålla rader där "Reseller Sales"[ProductKey] är lika med 229. Men efter uppdateringen filtreras GroupBy kolumner inom SummarizeColumns inte längre efter kolumner från externa tabeller, evenif det finns en relation mellan dem. I exemplet ovan kommer därför GroupBy kolumnen "Reseller Sales" [ProductKey] not filtreras efter kolumnenProduct[ProductKey]. Därför innehåller frågan rader där "Reseller Sales"[ProductKey] är not lika med 229.

If du föredrar att behålla previous beteende kan du skriva om uttrycket med hjälp av Summarize i stället för SummarizeColumns, enligt nedan:

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

Det här omskrivna uttrycket bevarar den ursprungliga semantiken där den GroupBy åtgärden not påverkas av den SelfValue-begränsning som introducerades av uppdateringen.

Radverifiering för groupby kolumner som helt omfattas av Treatas

Före den här uppdateringen täcktes ifallGroupBy kolumner från en viss tabell helt av en enda Treatasfilter från samma tabell i en SummarizeColumns funktion enligt nedan:

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

Resultatet av ovanstående fråga skulle innehålla de rader som angavs i Treatasfilter, oavsett om de var giltiga ornot. Resultatet skulle till exempel vara en tabell med en rad ("USA", "Alberta"), evenif ingen sådan rad med [Land] = "USA" and [State] = "Alberta" fanns i tabellen Geografi.

Det här problemet var känt and har åtgärdats av uppdateringen. Efter uppdateringen filtreras sådana ogiltiga rader bort, and endast giltiga rader från den GroupBy tabellen returneras. Därför skulle resultatet för frågan ovan vara tomt, eftersom det inte finns några giltiga rader som matchar det angivna [Land] and [State] values i tabellen Geografi.

Tillåt inte blandade Keepfilters/overriddefilters i samma tabell/kluster

Den senaste uppdateringen har infört en tillfällig begränsning som utlöser ett error meddelande som anger:

"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." 

Det här error inträffar när både normala filters (som åsidosätter befintliga filters) andfilters med angivna KeepFilters finns i samma tabell/kluster. Till exempel:

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

I uttrycket ovan finns det två filters i tabellen Geografi: en med KeepFilters angiven and en utan. Dessa filters överlappa externa filters på olika kolumner. För närvarande är den här konfigurationen not tillåten eftersom de två filters internt är grupperade i en, and systemet inte kan fastställa rätt filter övergripande beteende för klustrade filter i sådana fall.

Observera att den här begränsningen är tillfällig. Vi utvecklar aktivt lösningar för att ta bort den här begränsningen i framtida uppdateringar. If du stöter på den här errorrekommenderar vi att du justerar filters inom SummarizeColumns genom att lägga till or att ta bort KeepFilters efter behov för att säkerställa konsekvent åsidosättande beteende i varje tabell.

Related innehåll

SUMMARIZE