@luquimbo/bi-superpowers 1.0.0

package/library/snippets/dax/virtual-tables.md

@@ -0,0 +1,546 @@
+# Virtual Tables in DAX
+
+Patterns for creating and using virtual tables with SUMMARIZE, ADDCOLUMNS, SELECTCOLUMNS, GENERATE, and table functions.
+
+---
+
+## Why Use Virtual Tables? (Business Perspective)
+
+**The Problem:** You need to perform calculations that require intermediate steps, like ranking products within each category or calculating running totals.
+
+**The Solution:** Virtual tables let you create temporary "helper tables" during calculation that exist only while the formula runs.
+
+### Real-World Business Examples
+
+| Business Need | Virtual Table Approach |
+|--------------|------------------------|
+| Top 5 products per region | TOPN + SUMMARIZE creates ranked subsets |
+| ABC analysis (Pareto) | ADDCOLUMNS + cumulative % classification |
+| Sales vs. comparable products | GENERATE creates product pairs for comparison |
+| Year-over-year by segment | SUMMARIZE groups data for time comparison |
+
+### When Should You Use Virtual Tables?
+
+**Use virtual tables when:**
+- You need intermediate calculations (e.g., rank, then filter, then sum)
+- You're building complex metrics that require grouped data
+- You need to create temporary lookup structures
+- Standard measures can't express your business logic
+
+**Be careful when:**
+- Tables are very large (millions of rows) - consider query performance
+- You can achieve the same result with simpler CALCULATE patterns
+- You're nesting too many virtual tables (hard to debug)
+
+---
+
+## Common Mistakes to Avoid
+
+| Mistake | Problem | Solution |
+|---------|---------|----------|
+| SUMMARIZE with measures | Unreliable context behavior | Use ADDCOLUMNS + SUMMARIZE pattern |
+| Large virtual tables in visuals | Slow report rendering | Materialize to a physical table or simplify |
+| Not using VAR | Recalculates table multiple times | Store in VAR for reuse |
+| Nested FILTER inside SUMX | Quadratic performance | Pre-filter with CALCULATETABLE |
+| Using ALL(Table) vs VALUES | Wrong granularity | VALUES respects filters, ALL ignores them |
+
+---
+
+## SUMMARIZE Patterns
+
+### Basic Grouping
+
+```dax
+-- Summarize sales by category
+CategorySummary =
+SUMMARIZE(
+    Sales,
+    Products[Category],
+    "Total Sales", SUM(Sales[Amount]),
+    "Order Count", COUNTROWS(Sales)
+)
+```
+
+### Multi-Level Grouping
+
+```dax
+-- Summarize by category and year
+Category_Year_Summary =
+SUMMARIZE(
+    Sales,
+    Products[Category],
+    'Date'[Year],
+    "Total Sales", SUM(Sales[Amount]),
+    "Avg Order", AVERAGE(Sales[Amount])
+)
+```
+
+### SUMMARIZE with ROLLUP
+
+```dax
+-- Include subtotals
+SummaryWithSubtotals =
+SUMMARIZE(
+    Sales,
+    ROLLUP(Products[Category], Products[SubCategory]),
+    "Sales", SUM(Sales[Amount])
+)
+```
+
+### Safe SUMMARIZE Pattern
+
+```dax
+-- Best practice: Use ADDCOLUMNS with SUMMARIZE
+CategorySales_Safe =
+ADDCOLUMNS(
+    SUMMARIZE(
+        Sales,
+        Products[Category]
+    ),
+    "@Sales", CALCULATE(SUM(Sales[Amount])),
+    "@Orders", CALCULATE(COUNTROWS(Sales))
+)
+```
+
+---
+
+## ADDCOLUMNS Patterns
+
+### Extend Table with Calculated Columns
+
+```dax
+-- Add calculated columns to product table
+ProductMetrics =
+ADDCOLUMNS(
+    VALUES(Products[ProductName]),
+    "@TotalSales", CALCULATE(SUM(Sales[Amount])),
+    "@TotalUnits", CALCULATE(SUM(Sales[Quantity])),
+    "@AvgPrice", CALCULATE(AVERAGE(Sales[UnitPrice]))
+)
+```
+
+### Multi-Level Calculations
+
+```dax
+-- Add columns in stages for complex calculations
+CustomerAnalysis =
+VAR _Base =
+    ADDCOLUMNS(
+        VALUES(Customers[CustomerID]),
+        "@Sales", CALCULATE(SUM(Sales[Amount])),
+        "@Orders", CALCULATE(COUNTROWS(Sales))
+    )
+RETURN
+    ADDCOLUMNS(
+        _Base,
+        "@AvgOrderValue", DIVIDE([@Sales], [@Orders]),
+        "@Tier", IF([@Sales] > 10000, "Premium", IF([@Sales] > 5000, "Standard", "Basic"))
+    )
+```
+
+### ADDCOLUMNS for KPI Dashboard
+
+```dax
+-- Create KPI virtual table
+KPI_Table =
+ADDCOLUMNS(
+    SUMMARIZE(
+        Sales,
+        'Date'[Year],
+        'Date'[Month]
+    ),
+    "@Revenue", CALCULATE(SUM(Sales[Amount])),
+    "@Cost", CALCULATE(SUM(Sales[Cost])),
+    "@Profit", CALCULATE(SUM(Sales[Amount]) - SUM(Sales[Cost])),
+    "@Margin", DIVIDE(
+        CALCULATE(SUM(Sales[Amount]) - SUM(Sales[Cost])),
+        CALCULATE(SUM(Sales[Amount]))
+    )
+)
+```
+
+---
+
+## SELECTCOLUMNS Patterns
+
+### Select Specific Columns
+
+```dax
+-- Create slim table with renamed columns
+CustomerList =
+SELECTCOLUMNS(
+    Customers,
+    "ID", Customers[CustomerID],
+    "Name", Customers[CustomerName],
+    "Email", Customers[Email]
+)
+```
+
+### Transform and Rename
+
+```dax
+-- Transform column values
+ProductPricing =
+SELECTCOLUMNS(
+    Products,
+    "Product", Products[ProductName],
+    "List Price", Products[Price],
+    "Discounted", Products[Price] * 0.9,
+    "Premium", Products[Price] * 1.2
+)
+```
+
+### Combine with Filter
+
+```dax
+-- Select from filtered table
+ActiveCustomers =
+SELECTCOLUMNS(
+    FILTER(
+        Customers,
+        Customers[Status] = "Active"
+    ),
+    "Customer", Customers[CustomerName],
+    "Since", Customers[JoinDate]
+)
+```
+
+---
+
+## GENERATE / GENERATEALL Patterns
+
+### Cross Join with Calculation
+
+```dax
+-- Generate customer-product matrix
+Customer_Product_Matrix =
+GENERATE(
+    VALUES(Customers[CustomerName]),
+    ADDCOLUMNS(
+        VALUES(Products[ProductName]),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+)
+```
+
+### Date-Based Generation
+
+```dax
+-- Generate date ranges with metrics
+Monthly_Metrics =
+GENERATE(
+    VALUES('Date'[YearMonth]),
+    ROW(
+        "@Sales", CALCULATE(SUM(Sales[Amount])),
+        "@Units", CALCULATE(SUM(Sales[Quantity])),
+        "@Customers", CALCULATE(DISTINCTCOUNT(Sales[CustomerID]))
+    )
+)
+```
+
+### GENERATEALL for Complete Matrix
+
+```dax
+-- Include empty combinations
+Full_Matrix =
+GENERATEALL(
+    VALUES(Products[Category]),
+    ADDCOLUMNS(
+        VALUES('Date'[Year]),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+)
+```
+
+---
+
+## UNION / INTERSECT / EXCEPT Patterns
+
+### UNION - Combine Tables
+
+```dax
+-- Combine actual and budget
+Actual_And_Budget =
+UNION(
+    SELECTCOLUMNS(
+        ActualSales,
+        "Type", "Actual",
+        "Date", ActualSales[Date],
+        "Amount", ActualSales[Amount]
+    ),
+    SELECTCOLUMNS(
+        BudgetSales,
+        "Type", "Budget",
+        "Date", BudgetSales[Date],
+        "Amount", BudgetSales[Amount]
+    )
+)
+```
+
+### INTERSECT - Common Values
+
+```dax
+-- Customers who bought both categories
+Crossover_Customers =
+VAR _ElectronicsBuyers =
+    CALCULATETABLE(
+        VALUES(Sales[CustomerID]),
+        Products[Category] = "Electronics"
+    )
+VAR _ClothingBuyers =
+    CALCULATETABLE(
+        VALUES(Sales[CustomerID]),
+        Products[Category] = "Clothing"
+    )
+RETURN
+    COUNTROWS(INTERSECT(_ElectronicsBuyers, _ClothingBuyers))
+```
+
+### EXCEPT - Difference
+
+```dax
+-- Products never sold
+Unsold_Products =
+EXCEPT(
+    ALL(Products[ProductID]),
+    VALUES(Sales[ProductID])
+)
+```
+
+---
+
+## DATATABLE / ROW Patterns
+
+### Static Reference Table
+
+```dax
+-- Create status reference
+StatusColors =
+DATATABLE(
+    "Status", STRING,
+    "Color", STRING,
+    "Priority", INTEGER,
+    {
+        {"Critical", "#FF0000", 1},
+        {"Warning", "#FFA500", 2},
+        {"Normal", "#00FF00", 3},
+        {"Low", "#808080", 4}
+    }
+)
+```
+
+### Single Row Table
+
+```dax
+-- Create single row for calculation
+Thresholds =
+ROW(
+    "LowThreshold", 0.1,
+    "MediumThreshold", 0.5,
+    "HighThreshold", 0.9
+)
+```
+
+### Combine with LOOKUPVALUE
+
+```dax
+-- Lookup from static table
+StatusColor =
+VAR _Status = [OrderStatus]
+RETURN
+    LOOKUPVALUE(
+        StatusColors[Color],
+        StatusColors[Status], _Status
+    )
+```
+
+---
+
+## NATURALINNERJOIN / NATURALLEFTOUTERJOIN
+
+### Inner Join Tables
+
+```dax
+-- Join sales with products
+SalesWithProduct =
+NATURALINNERJOIN(
+    SELECTCOLUMNS(Sales, "ProductID", Sales[ProductID], "Amount", Sales[Amount]),
+    SELECTCOLUMNS(Products, "ProductID", Products[ProductID], "Name", Products[ProductName])
+)
+```
+
+### Left Outer Join
+
+```dax
+-- All products with optional sales data
+ProductsWithSales =
+NATURALLEFTOUTERJOIN(
+    SELECTCOLUMNS(Products, "ProductID", Products[ProductID], "Name", Products[ProductName]),
+    ADDCOLUMNS(
+        SUMMARIZE(Sales, Sales[ProductID]),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+)
+```
+
+---
+
+## TREATAS Pattern
+
+### Virtual Relationship
+
+```dax
+-- Apply filter from disconnected table
+Sales_Budget_Products =
+CALCULATE(
+    SUM(Sales[Amount]),
+    TREATAS(
+        VALUES(Budget[ProductID]),
+        Products[ProductID]
+    )
+)
+```
+
+### Cross-Table Analysis
+
+```dax
+-- Compare two disconnected tables
+Budget_vs_Actual =
+VAR _BudgetProducts = VALUES(Budget[ProductID])
+VAR _ActualSales =
+    CALCULATE(
+        SUM(Sales[Amount]),
+        TREATAS(_BudgetProducts, Products[ProductID])
+    )
+VAR _BudgetAmount = SUM(Budget[Amount])
+RETURN
+    DIVIDE(_ActualSales - _BudgetAmount, _BudgetAmount)
+```
+
+---
+
+## Performance Patterns
+
+### Materialized vs Non-Materialized
+
+```dax
+-- Good: Materialize once, use multiple times
+Calculation_Optimized =
+VAR _CustomerTable =
+    ADDCOLUMNS(
+        VALUES(Customers[CustomerID]),
+        "@Sales", CALCULATE(SUM(Sales[Amount])),
+        "@Orders", CALCULATE(COUNTROWS(Sales))
+    )
+VAR _AvgSales = AVERAGEX(_CustomerTable, [@Sales])
+VAR _AvgOrders = AVERAGEX(_CustomerTable, [@Orders])
+RETURN
+    DIVIDE(_AvgSales, _AvgOrders)
+```
+
+### Avoid Repeated Calculation
+
+```dax
+-- Bad: Calculates multiple times
+Result_Bad =
+SUMX(
+    ADDCOLUMNS(
+        Products,
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    ),
+    [@Sales] * 0.1
+) +
+SUMX(
+    ADDCOLUMNS(
+        Products,
+        "@Sales", CALCULATE(SUM(Sales[Amount]))  -- Repeated!
+    ),
+    [@Sales] * 0.05
+)
+
+-- Good: Calculate once
+Result_Good =
+VAR _ProductSales =
+    ADDCOLUMNS(
+        ALL(Products),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+RETURN
+    SUMX(_ProductSales, [@Sales] * 0.1) +
+    SUMX(_ProductSales, [@Sales] * 0.05)
+```
+
+---
+
+## Common Virtual Table Measure Pattern
+
+### Measure That Returns Table Info
+
+```dax
+-- Count of profitable products
+Profitable_Product_Count =
+VAR _ProductProfits =
+    ADDCOLUMNS(
+        ALL(Products[ProductID]),
+        "@Profit", CALCULATE(SUM(Sales[Amount]) - SUM(Sales[Cost]))
+    )
+VAR _ProfitableProducts =
+    FILTER(_ProductProfits, [@Profit] > 0)
+RETURN
+    COUNTROWS(_ProfitableProducts)
+```
+
+### Dynamic ABC Classification
+
+```dax
+-- ABC analysis using virtual table
+ABC_Class =
+VAR _AllProducts =
+    ADDCOLUMNS(
+        ALL(Products[ProductName]),
+        "@Sales", CALCULATE(SUM(Sales[Amount]))
+    )
+VAR _TotalSales = SUMX(_AllProducts, [@Sales])
+VAR _Sorted =
+    ADDCOLUMNS(
+        _AllProducts,
+        "@CumPct",
+        VAR _CurrentSales = [@Sales]
+        VAR _Higher = SUMX(FILTER(_AllProducts, [@Sales] >= _CurrentSales), [@Sales])
+        RETURN DIVIDE(_Higher, _TotalSales)
+    )
+VAR _CurrentProduct = SELECTEDVALUE(Products[ProductName])
+VAR _CumPct =
+    MAXX(FILTER(_Sorted, [ProductName] = _CurrentProduct), [@CumPct])
+RETURN
+    SWITCH(
+        TRUE(),
+        _CumPct <= 0.7, "A",
+        _CumPct <= 0.9, "B",
+        "C"
+    )
+```
+
+---
+
+## Usage Notes
+
+1. **Virtual tables exist only during calculation** - They're not stored in the model
+2. **Use ADDCOLUMNS + SUMMARIZE** - Safer than putting aggregations directly in SUMMARIZE
+3. **Materialize to variables** - Store virtual tables in VAR for reuse
+4. **SELECTCOLUMNS for slim tables** - Reduces memory when you only need specific columns
+5. **GENERATE for cross-joins** - Creates row combinations with calculations
+6. **TREATAS for virtual relationships** - Applies filters across disconnected tables
+
+## Function Comparison
+
+| Function | Purpose | Returns |
+|----------|---------|---------|
+| SUMMARIZE | Group and aggregate | Grouped table |
+| ADDCOLUMNS | Add calculated columns | Extended table |
+| SELECTCOLUMNS | Pick/rename columns | Slimmed table |
+| GENERATE | Cross-join with calc | Combined table |
+| FILTER | Row-wise filter | Filtered table |
+| DISTINCT/VALUES | Unique values | Distinct table |
+| UNION | Combine tables | Merged table |
+| TREATAS | Apply lineage | Filtered table |

package/library/snippets/excel-formulas/README.md

@@ -0,0 +1,84 @@
+# Excel Formula Snippets
+
+Collection of reusable Excel formulas for modern Excel (365/2021+).
+
+## Available Snippets
+
+| File | Description |
+|------|-------------|
+| [lookups.md](./lookups.md) | XLOOKUP, INDEX/MATCH, VLOOKUP patterns |
+| [dynamic-arrays.md](./dynamic-arrays.md) | FILTER, SORT, UNIQUE, LET, SEQUENCE |
+| [aggregations.md](./aggregations.md) | SUMIFS, COUNTIFS, AVERAGEIFS, MAXIFS |
+| [dates-and-times.md](./dates-and-times.md) | Date calculations, workdays, age |
+| [text-functions.md](./text-functions.md) | Text manipulation, extraction, parsing |
+
+## Quick Reference
+
+### Lookups
+```excel
+=XLOOKUP(A2, tbl_Products[ID], tbl_Products[Name], "Not Found")
+=INDEX(Range, MATCH(A2, LookupRange, 0))
+```
+
+### Dynamic Arrays
+```excel
+=FILTER(tbl_Sales, tbl_Sales[Region]="North")
+=SORT(UNIQUE(tbl_Sales[Customer]))
+=TAKE(SORT(tbl_Sales, 3, -1), 10)
+```
+
+### Aggregations
+```excel
+=SUMIFS(tbl_Sales[Amount], tbl_Sales[Region], "North", tbl_Sales[Year], 2024)
+=AVERAGEIFS(tbl_Sales[Amount], tbl_Sales[Product], A2)
+```
+
+### LET Pattern
+```excel
+=LET(
+    data, FILTER(tbl_Sales, tbl_Sales[Active]=TRUE),
+    total, SUM(INDEX(data, , 3)),
+    total
+)
+```
+
+## Categories
+
+- **Lookups**: XLOOKUP, INDEX/MATCH, VLOOKUP, approximate matches
+- **Dynamic Arrays**: FILTER, SORT, UNIQUE, SEQUENCE, TAKE, DROP
+- **Aggregations**: SUMIFS, COUNTIFS, conditional aggregation
+- **Dates**: WORKDAY, NETWORKDAYS, EOMONTH, date math
+- **Text**: TEXTJOIN, TEXTSPLIT, parsing and formatting
+
+## Best Practices
+
+1. Use structured references: `tbl_Sales[Amount]` not `C:C`
+2. Prefer XLOOKUP over VLOOKUP for new spreadsheets
+3. Use LET for complex formulas (readability + performance)
+4. Prefer FILTER over helper columns for dynamic lists
+5. Use table names with `tbl_` prefix for clarity
+
+## Dynamic Array Tips
+
+- Arrays spill automatically to adjacent cells
+- Reference spill range with `#`: `=SUM(A1#)`
+- Use `@` for single value: `=@SORT(A:A)`
+- Combine functions: `=SORT(FILTER(UNIQUE(...)))`
+
+## Compatibility Notes
+
+| Feature | Excel 365 | Excel 2021 | Excel 2019 |
+|---------|-----------|------------|------------|
+| XLOOKUP | Yes | Yes | No |
+| FILTER | Yes | Yes | No |
+| LET | Yes | Yes | No |
+| LAMBDA | Yes | No | No |
+| TAKE/DROP | Yes | No | No |
+
+## Contributing
+
+Add new snippets as `.md` files with:
+- Clear title and description
+- Working formula examples
+- Explanation of parameters
+- Compatibility notes if needed