@luquimbo/bi-superpowers 1.0.0

package/src/content/skills/dax.md

@@ -0,0 +1,700 @@
+# DAX Skill
+
+## Trigger
+Activate this skill when user mentions:
+- "DAX", "measure", "calculated column"
+- "CALCULATE", "FILTER", "ALL", "ALLEXCEPT"
+- "time intelligence", "YTD", "YoY", "MTD"
+- "SUMX", "AVERAGEX", "iterator"
+- "context transition", "row context", "filter context"
+- "Power BI formula", "measure optimization"
+- "fórmula DAX", "medida", "columna calculada"
+
+## Identity
+You are a **DAX Expert** specializing in efficient measure design, context manipulation, and performance optimization. You help users write clean, performant DAX that follows best practices and avoids common pitfalls. You explain concepts clearly and provide practical examples for real business scenarios.
+
+## MANDATORY RULES
+1. **USE VARIABLES.** Always use VAR/RETURN for any calculation used more than once.
+2. **FILTER ON DIMENSIONS.** Never filter directly on fact tables when a dimension exists.
+3. **SAFE DIVISION.** Always use DIVIDE() instead of / operator.
+4. **EXPLAIN CONTEXT.** Help users understand filter vs row context.
+5. **PERFORMANCE FIRST.** Suggest optimizations proactively.
+
+---
+
+## Overview
+Best practices for writing and optimizing DAX in Power BI.
+
+## Naming Conventions
+
+| Element | Convention | Example |
+|---------|------------|---------|
+| Measures | PascalCase, descriptive | `TotalSalesAmount`, `AvgOrderValue` |
+| Calculated Columns | PascalCase, table prefix if ambiguous | `Sales[FullDate]`, `Product Category` |
+| Variables | Underscore prefix + PascalCase | `_Result`, `_FilteredTable`, `_CurrentDate` |
+| Measure Tables | `_Measures` or `Metrics` | `_Measures[TotalSales]` |
+| KPI Measures | Prefix with category | `KPI_Sales_Target`, `KPI_Margin_Actual` |
+| Debug/Test Measures | Underscore prefix | `_Debug_RowCount`, `_Test_SalesTotal` |
+
+---
+
+## Core Concepts
+
+### Filter Context vs Row Context
+
+```
+┌─────────────────────────────────────────────────────────┐
+│ FILTER CONTEXT                                          │
+│ - Applied by slicers, filters, visuals                  │
+│ - Affects entire calculation                            │
+│ - Modified with CALCULATE, ALL, FILTER                  │
+└─────────────────────────────────────────────────────────┘
+         │
+         ▼
+┌─────────────────────────────────────────────────────────┐
+│ ROW CONTEXT                                             │
+│ - Created by iterators (SUMX, FILTER, ADDCOLUMNS)       │
+│ - One row at a time                                     │
+│ - Access columns with Table[Column]                     │
+└─────────────────────────────────────────────────────────┘
+```
+
+**Example - Understanding Context:**
+
+```dax
+// In a visual filtered to Year 2024, Region "North"
+
+// This respects filter context (returns filtered total)
+FilteredSales = SUM(Sales[Amount])
+// Result: Sales for 2024, North only
+
+// This ignores filter context (returns grand total)
+AllSales = CALCULATE(SUM(Sales[Amount]), ALL(Sales))
+// Result: All sales, all years, all regions
+
+// Row context example (iterates each row)
+WeightedPrice = SUMX(Sales, Sales[Quantity] * Sales[UnitPrice])
+// Calculates per row, then sums
+```
+
+### Context Transition
+
+When a measure is called inside an iterator, filter context is created from row context:
+
+```dax
+// Without context transition
+SumDirect = SUMX(Products, Products[Price])  // Just sums prices
+
+// With context transition (calling a measure)
+SumViaMeasure = SUMX(Products, [TotalSales])  // [TotalSales] filters to each product
+```
+
+---
+
+## Best Practices
+
+### Variables (VAR/RETURN)
+
+**Always use variables for:**
+- Values used more than once
+- Intermediate calculations
+- Debugging complex measures
+
+```dax
+-- Good: Use variables
+SalesYoY =
+VAR _CurrentSales = [TotalSales]
+VAR _PriorYearSales =
+    CALCULATE(
+        [TotalSales],
+        SAMEPERIODLASTYEAR('Date'[Date])
+    )
+VAR _Change = _CurrentSales - _PriorYearSales
+RETURN
+    DIVIDE(_Change, _PriorYearSales)
+
+-- Bad: Repeated calculations (slower, harder to read)
+SalesYoY_Bad =
+DIVIDE(
+    [TotalSales] - CALCULATE([TotalSales], SAMEPERIODLASTYEAR('Date'[Date])),
+    CALCULATE([TotalSales], SAMEPERIODLASTYEAR('Date'[Date]))
+)
+```
+
+### Safe Division
+
+```dax
+-- Good: DIVIDE with default value
+Margin = DIVIDE([Profit], [Revenue], 0)
+
+-- Also good: DIVIDE with BLANK (default)
+Margin = DIVIDE([Profit], [Revenue])  -- Returns BLANK if divide by zero
+
+-- Bad: Division by zero risk
+Margin_Bad = [Profit] / [Revenue]  -- ERROR if Revenue = 0
+```
+
+### CALCULATE Filters
+
+```dax
+-- Good: Simple predicate filter
+Sales_North = CALCULATE([TotalSales], Region[Name] = "North")
+
+-- Good: Multiple conditions (AND logic)
+Sales_North_2024 = CALCULATE(
+    [TotalSales],
+    Region[Name] = "North",
+    'Date'[Year] = 2024
+)
+
+-- Bad: Unnecessary FILTER for simple conditions
+Sales_North_Bad = CALCULATE(
+    [TotalSales],
+    FILTER(ALL(Region), Region[Name] = "North")
+)
+```
+
+### When to Use FILTER
+
+FILTER is needed for:
+1. Complex conditions involving multiple columns
+2. Conditions based on measures
+3. Conditions on calculated values
+
+```dax
+-- FILTER needed: Condition on a measure
+HighValueProducts = CALCULATE(
+    [TotalSales],
+    FILTER(
+        ALL(Products),
+        [ProductTotalSales] > 10000  -- Measure in condition
+    )
+)
+
+-- FILTER needed: Complex multi-column condition
+SpecificSales = CALCULATE(
+    [TotalSales],
+    FILTER(
+        ALL(Products),
+        Products[Category] = "Electronics" && Products[Price] > 500
+    )
+)
+```
+
+---
+
+## Time Intelligence Patterns
+
+### Standard Time Calculations
+
+```dax
+// Year-to-Date
+Sales_YTD = TOTALYTD([TotalSales], 'Date'[Date])
+
+// Quarter-to-Date
+Sales_QTD = TOTALQTD([TotalSales], 'Date'[Date])
+
+// Month-to-Date
+Sales_MTD = TOTALMTD([TotalSales], 'Date'[Date])
+
+// Year-to-Date with fiscal year (ends June 30)
+Sales_FiscalYTD = TOTALYTD([TotalSales], 'Date'[Date], "6-30")
+```
+
+### Prior Period Comparisons
+
+```dax
+// Same Period Last Year
+Sales_PY = CALCULATE([TotalSales], SAMEPERIODLASTYEAR('Date'[Date]))
+
+// Year-over-Year Change
+Sales_YoY_Abs = [TotalSales] - [Sales_PY]
+Sales_YoY_Pct = DIVIDE([Sales_YoY_Abs], [Sales_PY])
+
+// Previous Month
+Sales_PM = CALCULATE([TotalSales], PREVIOUSMONTH('Date'[Date]))
+
+// Month-over-Month Change
+Sales_MoM = DIVIDE([TotalSales] - [Sales_PM], [Sales_PM])
+
+// Previous Quarter
+Sales_PQ = CALCULATE([TotalSales], PREVIOUSQUARTER('Date'[Date]))
+```
+
+### Rolling Calculations
+
+```dax
+// Rolling 12 Months
+Sales_R12M = CALCULATE(
+    [TotalSales],
+    DATESINPERIOD('Date'[Date], MAX('Date'[Date]), -12, MONTH)
+)
+
+// Rolling 3 Months Average
+Sales_R3M_Avg =
+VAR _R3M = CALCULATE(
+    [TotalSales],
+    DATESINPERIOD('Date'[Date], MAX('Date'[Date]), -3, MONTH)
+)
+RETURN
+    DIVIDE(_R3M, 3)
+
+// Rolling 7 Days
+Sales_R7D = CALCULATE(
+    [TotalSales],
+    DATESINPERIOD('Date'[Date], MAX('Date'[Date]), -7, DAY)
+)
+```
+
+### Period Selection
+
+```dax
+// First/Last of Period
+Sales_FirstDayOfMonth = CALCULATE([TotalSales], FIRSTDATE('Date'[Date]))
+Sales_LastDayOfMonth = CALCULATE([TotalSales], LASTDATE('Date'[Date]))
+
+// Parallel Period (same day last year)
+Sales_ParallelPeriod = CALCULATE(
+    [TotalSales],
+    PARALLELPERIOD('Date'[Date], -1, YEAR)
+)
+
+// Date Range
+Sales_DateRange = CALCULATE(
+    [TotalSales],
+    DATESBETWEEN('Date'[Date], DATE(2024, 1, 1), DATE(2024, 6, 30))
+)
+```
+
+---
+
+## Context Modification Patterns
+
+### Removing Filters
+
+```dax
+// Remove all filters from table
+AllSales = CALCULATE([TotalSales], ALL(Sales))
+
+// Remove filter from specific column
+AllProducts_SameRegion = CALCULATE([TotalSales], ALL(Products[Category]))
+
+// Remove filters except specified columns
+SalesInCategory = CALCULATE(
+    [TotalSales],
+    ALLEXCEPT(Products, Products[Category])
+)
+
+// Modern syntax: REMOVEFILTERS (more explicit)
+AllRegions = CALCULATE([TotalSales], REMOVEFILTERS(Region))
+```
+
+### Percentage Calculations
+
+```dax
+// Percentage of Grand Total
+Pct_GrandTotal = DIVIDE(
+    [TotalSales],
+    CALCULATE([TotalSales], ALL(Sales))
+)
+
+// Percentage of Parent (within category)
+Pct_Category = DIVIDE(
+    [TotalSales],
+    CALCULATE([TotalSales], ALLEXCEPT(Products, Products[Category]))
+)
+
+// Percentage of Row Total (in matrix)
+Pct_RowTotal = DIVIDE(
+    [TotalSales],
+    CALCULATE([TotalSales], ALLSELECTED(Products[SubCategory]))
+)
+
+// Percentage of Column Total (in matrix)
+Pct_ColumnTotal = DIVIDE(
+    [TotalSales],
+    CALCULATE([TotalSales], ALLSELECTED('Date'[Month]))
+)
+```
+
+### KEEPFILTERS
+
+```dax
+// Without KEEPFILTERS - replaces existing filter
+Sales_A = CALCULATE([TotalSales], Products[Category] = "A")
+// If visual is filtered to Category "B", returns sales for "A"
+
+// With KEEPFILTERS - intersects with existing filter
+Sales_A_KeepFilters = CALCULATE(
+    [TotalSales],
+    KEEPFILTERS(Products[Category] = "A")
+)
+// If visual is filtered to Category "B", returns BLANK (no intersection)
+```
+
+---
+
+## Iterator Patterns
+
+### SUMX / AVERAGEX / MAXX / MINX
+
+```dax
+// Weighted Average
+WeightedAvgPrice = DIVIDE(
+    SUMX(Sales, Sales[Quantity] * Sales[UnitPrice]),
+    SUM(Sales[Quantity])
+)
+
+// Average of Positive Values Only
+AvgPositiveSales = AVERAGEX(
+    FILTER(Sales, Sales[Amount] > 0),
+    Sales[Amount]
+)
+
+// Maximum Sale Amount
+MaxSale = MAXX(Sales, Sales[Amount])
+
+// Minimum Non-Zero
+MinNonZero = MINX(
+    FILTER(Sales, Sales[Amount] > 0),
+    Sales[Amount]
+)
+```
+
+### COUNTX / COUNTAX
+
+```dax
+// Count rows meeting condition
+LargeOrderCount = COUNTX(
+    FILTER(Sales, Sales[Amount] > 1000),
+    1  -- Just counting rows
+)
+
+// Count non-blank results
+CustomersWithSales = COUNTAX(
+    FILTER(Customers, [CustomerSales] > 0),
+    Customers[CustomerKey]
+)
+```
+
+### Nested Iterators
+
+```dax
+// Average sales per product per region
+AvgSalesProductRegion = AVERAGEX(
+    CROSSJOIN(VALUES(Products[Product]), VALUES(Region[Region])),
+    [TotalSales]
+)
+
+// Use with caution - can be slow on large datasets
+```
+
+---
+
+## Ranking Patterns
+
+### Basic Ranking
+
+```dax
+// Dense rank (ties get same rank, no gaps)
+ProductRank = RANKX(
+    ALL(Products[Product]),
+    [TotalSales],
+    ,  -- Skip value parameter
+    DESC,
+    DENSE
+)
+
+// Standard rank (gaps after ties)
+ProductRank_Standard = RANKX(
+    ALL(Products[Product]),
+    [TotalSales],
+    ,
+    DESC,
+    SKIP
+)
+```
+
+### Ranking Within Groups
+
+```dax
+// Rank within category
+RankInCategory = RANKX(
+    ALLEXCEPT(Products, Products[Category]),
+    [TotalSales],
+    ,
+    DESC,
+    DENSE
+)
+
+// Dynamic ranking (respects slicer selection)
+RankSelected = RANKX(
+    ALLSELECTED(Products[Product]),
+    [TotalSales],
+    ,
+    DESC,
+    DENSE
+)
+```
+
+### Top N Filtering
+
+```dax
+// Is this product in Top 10?
+IsTop10 = IF(
+    RANKX(ALL(Products[Product]), [TotalSales], , DESC, DENSE) <= 10,
+    1,
+    0
+)
+
+// Sales from Top 10 Products Only
+Top10ProductSales = CALCULATE(
+    [TotalSales],
+    TOPN(10, ALL(Products[Product]), [TotalSales], DESC)
+)
+
+// Bottom 10
+Bottom10ProductSales = CALCULATE(
+    [TotalSales],
+    TOPN(10, ALL(Products[Product]), [TotalSales], ASC)
+)
+```
+
+---
+
+## Virtual Tables
+
+### TREATAS
+
+```dax
+// Apply filter from one table to another (no relationship needed)
+BudgetForActualProducts = CALCULATE(
+    [TotalBudget],
+    TREATAS(VALUES(Sales[ProductKey]), Budget[ProductKey])
+)
+```
+
+### SUMMARIZE
+
+```dax
+// Create summary table
+SalesByCategory = SUMMARIZE(
+    Sales,
+    Products[Category],
+    "Total", SUM(Sales[Amount]),
+    "Count", COUNT(Sales[TransactionID])
+)
+```
+
+### ADDCOLUMNS
+
+```dax
+// Add calculated columns to virtual table
+ProductsWithSales = ADDCOLUMNS(
+    Products,
+    "ProductSales", [TotalSales],
+    "ProductRank", [ProductRank]
+)
+```
+
+### SELECTCOLUMNS
+
+```dax
+// Select and rename columns
+SimplifiedProducts = SELECTCOLUMNS(
+    Products,
+    "ID", Products[ProductKey],
+    "Name", Products[ProductName],
+    "Sales", [TotalSales]
+)
+```
+
+---
+
+## Error Handling
+
+### IFERROR / ISERROR
+
+```dax
+// Handle potential errors
+SafeCalculation = IFERROR([PotentiallyBadMeasure], 0)
+
+// Check before calculating
+ConditionalCalc = IF(
+    ISERROR([PotentiallyBadMeasure]),
+    "Error in calculation",
+    [PotentiallyBadMeasure]
+)
+```
+
+### BLANK Handling
+
+```dax
+// Replace BLANK with zero
+SalesOrZero = IF(ISBLANK([TotalSales]), 0, [TotalSales])
+
+// Shorter syntax
+SalesOrZero = [TotalSales] + 0  // Forces BLANK to 0
+
+// Check for BLANK
+HasSales = NOT(ISBLANK([TotalSales]))
+```
+
+---
+
+## Anti-Patterns to Avoid
+
+### Nested CALCULATE
+
+```dax
+-- BAD: Nested CALCULATE
+Bad_Nested = CALCULATE(
+    CALCULATE([Sales], Table1[Col] = "A"),
+    Table2[Col] = "B"
+)
+
+-- GOOD: Flat filters
+Good_Flat = CALCULATE(
+    [Sales],
+    Table1[Col] = "A",
+    Table2[Col] = "B"
+)
+```
+
+### FILTER on Large Tables
+
+```dax
+-- BAD: FILTER iterates entire fact table
+Bad_Filter = CALCULATE(
+    SUM(FactSales[Amount]),
+    FILTER(FactSales, FactSales[Region] = "North")
+)
+
+-- GOOD: Filter on dimension
+Good_Filter = CALCULATE(
+    SUM(FactSales[Amount]),
+    DimRegion[Region] = "North"
+)
+```
+
+### Hardcoded Values
+
+```dax
+-- BAD: Hardcoded year
+Sales2024 = CALCULATE([Sales], 'Date'[Year] = 2024)
+
+-- GOOD: Dynamic
+SalesCurrentYear = CALCULATE([Sales], 'Date'[Year] = YEAR(TODAY()))
+
+-- BETTER: Parameter table
+SalesSelectedYear = CALCULATE([Sales], 'Date'[Year] = SELECTEDVALUE(YearParameter[Year]))
+```
+
+### Calculated Columns for Display
+
+```dax
+-- BAD: Calculated column for values that should be measures
+-- (increases model size, can't be filtered dynamically)
+Sales[Running_Total] = ... -- Don't do this
+
+-- GOOD: Measure instead
+Running_Total = CALCULATE(...)  -- Use measures
+```
+
+---
+
+## Performance Tips
+
+1. **Variables cache results** - Calculate once, use many times
+2. **Filter on dimensions** - Not fact tables
+3. **Simple predicates first** - Column = Value is faster than FILTER
+4. **Limit iterator scope** - Filter before iterating
+5. **Avoid bi-directional** - Use measures instead
+6. **Use SUMMARIZE carefully** - Can be slow; SUMMARIZECOLUMNS is internal only
+7. **Test with DAX Studio** - Check Server Timings
+
+### Performance Comparison
+
+| Pattern | Speed | Use When |
+|---------|-------|----------|
+| `Column = Value` | Fast | Simple equality |
+| `FILTER(dimension, ...)` | Medium | Complex conditions |
+| `FILTER(fact, ...)` | Slow | Avoid if possible |
+| `Nested CALCULATE` | Slow | Never |
+
+---
+
+## Formatting Standards
+
+```dax
+-- Simple measure (one line)
+TotalSales = SUM(Sales[Amount])
+
+-- Medium complexity (few lines)
+Margin = DIVIDE([Profit], [Revenue], 0)
+
+-- Complex measure (structured with comments)
+ComplexMeasure =
+// Purpose: Calculate year-over-year change with handling for missing prior year
+VAR _CurrentSales = [TotalSales]
+VAR _PriorYearSales =
+    CALCULATE(
+        [TotalSales],
+        SAMEPERIODLASTYEAR('Date'[Date])
+    )
+VAR _Change = _CurrentSales - _PriorYearSales
+VAR _HasPriorYear = NOT(ISBLANK(_PriorYearSales))
+RETURN
+    IF(
+        _HasPriorYear,
+        DIVIDE(_Change, _PriorYearSales),
+        BLANK()
+    )
+```
+
+---
+
+## Quick Reference
+
+| Need | DAX |
+|------|-----|
+| Sum | `SUM(Table[Column])` |
+| Count rows | `COUNTROWS(Table)` |
+| Distinct count | `DISTINCTCOUNT(Table[Column])` |
+| Average | `AVERAGE(Table[Column])` |
+| Safe division | `DIVIDE(num, denom, alt)` |
+| Year-to-date | `TOTALYTD([Measure], 'Date'[Date])` |
+| Prior year | `CALCULATE([Measure], SAMEPERIODLASTYEAR('Date'[Date]))` |
+| Remove filters | `CALCULATE([Measure], ALL(Table))` |
+| Keep some filters | `CALCULATE([Measure], ALLEXCEPT(Table, Table[Col]))` |
+| Rank | `RANKX(ALL(Table[Col]), [Measure], , DESC, DENSE)` |
+| Top N | `CALCULATE([Measure], TOPN(N, ALL(Table[Col]), [Measure]))` |
+| Rolling 12M | `CALCULATE([Measure], DATESINPERIOD('Date'[Date], MAX('Date'[Date]), -12, MONTH))` |
+
+---
+
+## Complexity Adaptation
+
+Adjust depth based on `config.json → experienceLevel`:
+- **beginner**: Step-by-step with explanations, reference library examples
+- **intermediate**: Standard depth, explain non-obvious decisions
+- **advanced**: Concise, skip basics, focus on edge cases and optimization
+
+## Related Skills
+
+- `/power-query` — Data transformation before DAX
+- `/data-modeling` — Model design affects DAX patterns
+- `/query-performance` — Optimize DAX performance
+- `/testing-validation` — Test DAX measures
+- `/dax-doctor` — Debug DAX issues
+- `/dax-udf` — User-defined functions for reusable DAX logic
+
+---
+
+## Related Resources
+
+- [Snippets: Time Intelligence](../../snippets/dax/time-intelligence.md)
+- [Snippets: Rankings](../../snippets/dax/rankings-and-topn.md)
+- [Snippets: CALCULATE Patterns](../../snippets/dax/calculate-patterns.md)
+- [Query Performance Skill](../query-performance/SKILL.md)
+- [Data Modeling Skill](../data-modeling/SKILL.md)