@luquimbo/bi-superpowers 1.0.0

package/library/snippets/dax/iterators-and-aggregations.md

@@ -0,0 +1,474 @@
+# Iterator Functions and Advanced Aggregations
+
+Patterns for SUMX, AVERAGEX, MAXX, MINX, COUNTX, and related iterator functions.
+
+---
+
+## Basic Iterator Patterns
+
+### SUMX - Row-by-Row Calculation
+
+```dax
+-- Calculate extended price (quantity × unit price)
+Revenue =
+SUMX(
+    Sales,
+    Sales[Quantity] * Sales[UnitPrice]
+)
+```
+
+```dax
+-- With discount applied
+Revenue_Net =
+SUMX(
+    Sales,
+    Sales[Quantity] * Sales[UnitPrice] * (1 - Sales[Discount])
+)
+```
+
+### AVERAGEX - Average of Calculated Values
+
+```dax
+-- Average order value
+Avg_Order_Value =
+AVERAGEX(
+    VALUES(Sales[OrderID]),
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+```dax
+-- Average unit price weighted by quantity
+Weighted_Avg_Price =
+DIVIDE(
+    SUMX(Sales, Sales[Quantity] * Sales[UnitPrice]),
+    SUM(Sales[Quantity])
+)
+```
+
+### MAXX/MINX - Extremes of Calculated Values
+
+```dax
+-- Highest single transaction
+Max_Transaction =
+MAXX(
+    Sales,
+    Sales[Quantity] * Sales[UnitPrice]
+)
+```
+
+```dax
+-- Lowest performing product's sales
+Min_Product_Sales =
+MINX(
+    VALUES(Products[ProductName]),
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+```dax
+-- Best performing month
+Best_Month_Sales =
+MAXX(
+    VALUES('Date'[MonthYear]),
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+### COUNTX - Conditional Counting
+
+```dax
+-- Count high-value transactions
+High_Value_Count =
+COUNTX(
+    FILTER(Sales, Sales[Amount] > 1000),
+    Sales[TransactionID]
+)
+```
+
+```dax
+-- Count profitable products
+Profitable_Products =
+COUNTX(
+    FILTER(
+        ALL(Products),
+        CALCULATE([ProfitMargin]) > 0.15
+    ),
+    Products[ProductID]
+)
+```
+
+---
+
+## Advanced Iterator Patterns
+
+### Nested Iterators
+
+```dax
+-- Total by customer by product (double iteration)
+Customer_Product_Total =
+SUMX(
+    VALUES(Customers[CustomerName]),
+    SUMX(
+        VALUES(Products[ProductName]),
+        CALCULATE(SUM(Sales[Amount]))
+    )
+)
+```
+
+```dax
+-- Average of customer totals
+Avg_Customer_Total =
+AVERAGEX(
+    VALUES(Customers[CustomerID]),
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+### RANKX - Dynamic Rankings
+
+```dax
+-- Rank products by sales
+Product_Rank =
+RANKX(
+    ALL(Products[ProductName]),
+    CALCULATE(SUM(Sales[Amount])),
+    ,
+    DESC,
+    DENSE
+)
+```
+
+```dax
+-- Rank within category
+Product_Rank_InCategory =
+RANKX(
+    ALLEXCEPT(Products, Products[Category]),
+    CALCULATE(SUM(Sales[Amount])),
+    ,
+    DESC,
+    DENSE
+)
+```
+
+```dax
+-- Dynamic rank (respects filters)
+Product_Rank_Dynamic =
+IF(
+    HASONEVALUE(Products[ProductName]),
+    RANKX(
+        ALLSELECTED(Products[ProductName]),
+        CALCULATE(SUM(Sales[Amount])),
+        ,
+        DESC,
+        DENSE
+    )
+)
+```
+
+### CONCATENATEX - String Aggregation
+
+```dax
+-- List of products purchased
+Products_Purchased =
+CONCATENATEX(
+    VALUES(Products[ProductName]),
+    Products[ProductName],
+    ", ",
+    Products[ProductName], ASC
+)
+```
+
+```dax
+-- Top 3 products by sales
+Top3_Products =
+CONCATENATEX(
+    TOPN(
+        3,
+        VALUES(Products[ProductName]),
+        CALCULATE(SUM(Sales[Amount])),
+        DESC
+    ),
+    Products[ProductName],
+    ", ",
+    CALCULATE(SUM(Sales[Amount])), DESC
+)
+```
+
+### PRODUCTX - Compound Growth
+
+```dax
+-- Compound monthly growth rate
+CAGR =
+VAR _StartValue = CALCULATE(SUM(Sales[Amount]), FIRSTDATE('Date'[Date]))
+VAR _EndValue = CALCULATE(SUM(Sales[Amount]), LASTDATE('Date'[Date]))
+VAR _Periods = DATEDIFF(MIN('Date'[Date]), MAX('Date'[Date]), YEAR)
+RETURN
+    IF(
+        _Periods > 0 && _StartValue > 0,
+        POWER(DIVIDE(_EndValue, _StartValue), DIVIDE(1, _Periods)) - 1
+    )
+```
+
+```dax
+-- Geometric mean of growth rates
+Geometric_Avg_Growth =
+VAR _GrowthTable =
+    ADDCOLUMNS(
+        SUMMARIZE(Sales, 'Date'[Year]),
+        "@Growth", 1 + DIVIDE(
+            CALCULATE(SUM(Sales[Amount])) - CALCULATE(SUM(Sales[Amount]), PREVIOUSYEAR('Date'[Date])),
+            CALCULATE(SUM(Sales[Amount]), PREVIOUSYEAR('Date'[Date]))
+        )
+    )
+VAR _Product =
+    PRODUCTX(
+        FILTER(_GrowthTable, [@Growth] > 0),
+        [@Growth]
+    )
+VAR _Count =
+    COUNTROWS(FILTER(_GrowthTable, [@Growth] > 0))
+RETURN
+    IF(_Count > 0, POWER(_Product, 1 / _Count) - 1)
+```
+
+---
+
+## Performance-Optimized Patterns
+
+### Using Variables with Iterators
+
+```dax
+-- Optimized: Store table reference in variable
+Revenue_Optimized =
+VAR _SalesTable = Sales
+RETURN
+    SUMX(
+        _SalesTable,
+        [Quantity] * [UnitPrice]
+    )
+```
+
+```dax
+-- Avoid recalculating in iterator
+Margin_Optimized =
+VAR _TotalCost = SUM(Sales[Cost])
+VAR _TotalRevenue = SUM(Sales[Revenue])
+RETURN
+    DIVIDE(_TotalRevenue - _TotalCost, _TotalRevenue)
+```
+
+### GENERATE vs Nested SUMX
+
+```dax
+-- Using GENERATE for better performance
+Sales_Analysis =
+VAR _CustomerSales =
+    GENERATE(
+        VALUES(Customers[CustomerID]),
+        ROW("@Sales", CALCULATE(SUM(Sales[Amount])))
+    )
+RETURN
+    AVERAGEX(_CustomerSales, [@Sales])
+```
+
+### ADDCOLUMNS for Pre-Calculation
+
+```dax
+-- Pre-calculate values before iteration
+Avg_Profit_Margin =
+VAR _ProductMetrics =
+    ADDCOLUMNS(
+        ALL(Products[ProductName]),
+        "@Revenue", CALCULATE(SUM(Sales[Amount])),
+        "@Cost", CALCULATE(SUM(Sales[Cost]))
+    )
+RETURN
+    AVERAGEX(
+        _ProductMetrics,
+        DIVIDE([@Revenue] - [@Cost], [@Revenue])
+    )
+```
+
+---
+
+## Statistical Functions
+
+### Standard Deviation (Sample)
+
+```dax
+StdDev_Sales =
+VAR _Avg = AVERAGEX(VALUES('Date'[Month]), CALCULATE(SUM(Sales[Amount])))
+VAR _Variance =
+    AVERAGEX(
+        VALUES('Date'[Month]),
+        POWER(CALCULATE(SUM(Sales[Amount])) - _Avg, 2)
+    )
+RETURN
+    SQRT(_Variance)
+```
+
+### Median Using MEDIANX
+
+```dax
+Median_Order_Value =
+MEDIANX(
+    VALUES(Sales[OrderID]),
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+### Percentile Calculation
+
+```dax
+Percentile_75_Sales =
+VAR _AllCustomerSales =
+    ADDCOLUMNS(
+        VALUES(Customers[CustomerID]),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+VAR _75thPercentile =
+    PERCENTILEX.INC(_AllCustomerSales, [@Sales], 0.75)
+RETURN
+    _75thPercentile
+```
+
+### Coefficient of Variation
+
+```dax
+CV_Sales =
+VAR _Avg = AVERAGEX(VALUES('Date'[Month]), CALCULATE(SUM(Sales[Amount])))
+VAR _StdDev =
+    SQRT(
+        AVERAGEX(
+            VALUES('Date'[Month]),
+            POWER(CALCULATE(SUM(Sales[Amount])) - _Avg, 2)
+        )
+    )
+RETURN
+    DIVIDE(_StdDev, _Avg)
+```
+
+---
+
+## FILTER vs Iterator Performance
+
+### When to Use FILTER
+
+```dax
+-- Good: FILTER with simple column condition (foldable)
+Sales_HighValue =
+CALCULATE(
+    SUM(Sales[Amount]),
+    Sales[Amount] > 1000
+)
+
+-- Better than iterator when filtering on columns
+```
+
+### When to Use Iterator
+
+```dax
+-- Good: Complex row-by-row calculation
+Net_Revenue =
+SUMX(
+    Sales,
+    (Sales[Quantity] * Sales[UnitPrice]) - Sales[Discount] - Sales[Tax]
+)
+
+-- Necessary when calculation spans multiple columns per row
+```
+
+### Hybrid Approach
+
+```dax
+-- Combine for best performance
+Profitable_Revenue =
+SUMX(
+    FILTER(
+        Sales,
+        Sales[ProfitFlag] = TRUE()  -- Simple filter first
+    ),
+    Sales[Quantity] * Sales[UnitPrice] * (1 - Sales[Discount])  -- Then iterate
+)
+```
+
+---
+
+## Common Mistakes to Avoid
+
+### Mistake 1: Unnecessary Context Transition
+
+```dax
+-- Bad: Forces context transition on every row
+Revenue_Bad =
+SUMX(
+    Sales,
+    CALCULATE(Sales[Quantity] * Sales[UnitPrice])
+)
+
+-- Good: No CALCULATE needed
+Revenue_Good =
+SUMX(
+    Sales,
+    Sales[Quantity] * Sales[UnitPrice]
+)
+```
+
+### Mistake 2: Iterating Over Wrong Table
+
+```dax
+-- Bad: Iterates over entire table
+Avg_Product_Sales_Bad =
+AVERAGEX(
+    Sales,  -- Wrong! Iterates every row
+    Sales[Amount]
+)
+
+-- Good: Iterate over unique products
+Avg_Product_Sales_Good =
+AVERAGEX(
+    VALUES(Products[ProductName]),  -- Correct: One iteration per product
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+### Mistake 3: Missing ALL in Rankings
+
+```dax
+-- Bad: Rank doesn't work correctly with filters
+Rank_Bad =
+RANKX(
+    Products,  -- Wrong! Affected by filter context
+    [Sales]
+)
+
+-- Good: Use ALL for consistent ranking
+Rank_Good =
+RANKX(
+    ALL(Products[ProductName]),  -- Correct: Ranks all products
+    CALCULATE(SUM(Sales[Amount]))
+)
+```
+
+---
+
+## Usage Notes
+
+1. **Iterator functions iterate row by row** - They're powerful but can be slow on large tables
+2. **Use simple aggregations when possible** - SUM, AVERAGE, COUNT are faster than iterators
+3. **Pre-filter tables** - Use FILTER before SUMX to reduce iterations
+4. **Store repeated calculations in variables** - Avoid recalculating inside iterators
+5. **Use ADDCOLUMNS/GENERATE** - Create virtual tables for complex multi-step calculations
+6. **DENSE vs SKIP in RANKX** - DENSE: no gaps; SKIP: gaps for ties
+
+## Performance Guidelines
+
+| Operation | Rows | Performance |
+|-----------|------|-------------|
+| SUMX/AVERAGEX | < 100K | Fast |
+| SUMX/AVERAGEX | 100K - 1M | Monitor |
+| SUMX/AVERAGEX | > 1M | Optimize |
+| Nested iterators | Any | Expensive |
+| RANKX with ALL | < 10K unique | Fast |
+| RANKX with ALL | > 10K unique | Monitor |