@luquimbo/bi-superpowers 1.0.0

package/library/snippets/dax/error-handling.md

@@ -0,0 +1,495 @@
+# Error Handling and Defensive DAX
+
+Patterns for handling errors, blanks, edge cases, and creating robust measures.
+
+---
+
+## DIVIDE Function
+
+### Basic Safe Division
+
+```dax
+-- Always use DIVIDE instead of /
+Profit_Margin =
+DIVIDE(
+    SUM(Sales[Profit]),
+    SUM(Sales[Revenue])
+)
+-- Returns BLANK if denominator is 0 or blank
+```
+
+### Custom Alternate Result
+
+```dax
+-- Return 0 instead of BLANK
+Profit_Margin_Zero =
+DIVIDE(
+    SUM(Sales[Profit]),
+    SUM(Sales[Revenue]),
+    0  -- Return 0 when can't divide
+)
+```
+
+### Nested DIVIDE for Complex Calculations
+
+```dax
+-- Multiple divisions with safety
+Efficiency_Ratio =
+DIVIDE(
+    DIVIDE(SUM(Sales[Units]), SUM(Staff[Hours])),
+    DIVIDE(SUM(Budget[Units]), SUM(Budget[Hours])),
+    1  -- Return 1 (100%) if comparison not possible
+)
+```
+
+---
+
+## BLANK Handling
+
+### ISBLANK / BLANK
+
+```dax
+-- Check for blank and substitute
+Sales_Display =
+IF(
+    ISBLANK(SUM(Sales[Amount])),
+    0,
+    SUM(Sales[Amount])
+)
+```
+
+### COALESCE (DAX 2019+)
+
+```dax
+-- First non-blank value
+Customer_Contact =
+COALESCE(
+    [PreferredEmail],
+    [WorkEmail],
+    [PersonalEmail],
+    "No Email"
+)
+```
+
+```dax
+-- Chain of fallback values
+Revenue_Display =
+COALESCE(
+    [Actual Revenue],
+    [Forecast Revenue],
+    [Budget Revenue],
+    0
+)
+```
+
+### Handle Blank in Comparisons
+
+```dax
+-- Safe comparison with potential blanks
+Has_Sales =
+VAR _Sales = SUM(Sales[Amount])
+RETURN
+    IF(
+        ISBLANK(_Sales) || _Sales = 0,
+        "No",
+        "Yes"
+    )
+```
+
+---
+
+## Error Handling
+
+### IFERROR - Catch All Errors
+
+```dax
+-- Handle any calculation error
+Safe_Calculation =
+IFERROR(
+    [ComplexMeasure] / [AnotherMeasure],
+    BLANK()
+)
+```
+
+### ISERROR - Test Before Calculate
+
+```dax
+-- Test for error condition
+Error_Status =
+IF(
+    ISERROR([RiskyCalculation]),
+    "Error in calculation",
+    FORMAT([RiskyCalculation], "#,##0")
+)
+```
+
+### Error Handling in Iterators
+
+```dax
+-- Safe iteration with error handling
+Total_Safe =
+SUMX(
+    Sales,
+    IFERROR(
+        Sales[Quantity] * Sales[Price] / Sales[Discount],
+        Sales[Quantity] * Sales[Price]  -- Fallback if error
+    )
+)
+```
+
+---
+
+## Null and Empty String Handling
+
+### Distinguish BLANK from Empty String
+
+```dax
+-- Check for truly empty values
+Has_Value =
+VAR _Value = SELECTEDVALUE(Products[Description])
+RETURN
+    IF(
+        ISBLANK(_Value) || _Value = "",
+        FALSE(),
+        TRUE()
+    )
+```
+
+### Clean Text Input
+
+```dax
+-- Handle various empty states
+Clean_Name =
+VAR _Raw = SELECTEDVALUE(Customers[Name])
+RETURN
+    IF(
+        ISBLANK(_Raw) || TRIM(_Raw) = "" || _Raw = "N/A" || _Raw = "NULL",
+        "(Unknown)",
+        TRIM(_Raw)
+    )
+```
+
+---
+
+## Context Validation
+
+### HASONEVALUE - Single Selection Check
+
+```dax
+-- Only calculate if single value selected
+Unit_Price_Display =
+IF(
+    HASONEVALUE(Products[ProductName]),
+    SELECTEDVALUE(Products[UnitPrice]),
+    BLANK()  -- Don't show if multiple products
+)
+```
+
+### HASONEFILTER - Filter Check
+
+```dax
+-- Check if filter is applied
+Status_Message =
+IF(
+    HASONEFILTER(Products[Category]),
+    "Showing: " & SELECTEDVALUE(Products[Category]),
+    "All Categories"
+)
+```
+
+### ISFILTERED / ISCROSSFILTERED
+
+```dax
+-- Validate filter state
+Contextual_Result =
+SWITCH(
+    TRUE(),
+    NOT ISFILTERED(Products[Category]), [Total_All],
+    ISFILTERED(Products[Category]) && NOT ISCROSSFILTERED(Regions), [Total_Category],
+    [Total_Filtered]
+)
+```
+
+### SELECTEDVALUE with Fallback
+
+```dax
+-- Safe single value selection
+Selected_Product =
+SELECTEDVALUE(
+    Products[ProductName],
+    "(Multiple Products Selected)"  -- Default when not single value
+)
+```
+
+---
+
+## Date Validation
+
+### Check for Valid Dates
+
+```dax
+-- Validate date exists
+Days_Since_Order =
+VAR _OrderDate = MAX(Sales[OrderDate])
+VAR _Today = TODAY()
+RETURN
+    IF(
+        ISBLANK(_OrderDate) || _OrderDate > _Today,
+        BLANK(),
+        DATEDIFF(_OrderDate, _Today, DAY)
+    )
+```
+
+### Handle Date Range Edge Cases
+
+```dax
+-- Safe date period calculation
+Period_Sales =
+VAR _StartDate = MIN('Date'[Date])
+VAR _EndDate = MAX('Date'[Date])
+RETURN
+    IF(
+        ISBLANK(_StartDate) || ISBLANK(_EndDate) || _StartDate > _EndDate,
+        BLANK(),
+        CALCULATE(
+            SUM(Sales[Amount]),
+            'Date'[Date] >= _StartDate && 'Date'[Date] <= _EndDate
+        )
+    )
+```
+
+---
+
+## Data Quality Measures
+
+### Completeness Check
+
+```dax
+Data_Completeness =
+VAR _TotalRows = COUNTROWS(Sales)
+VAR _CompleteRows =
+    COUNTROWS(
+        FILTER(
+            Sales,
+            NOT ISBLANK(Sales[Amount])
+                && NOT ISBLANK(Sales[CustomerID])
+                && NOT ISBLANK(Sales[ProductID])
+                && NOT ISBLANK(Sales[Date])
+        )
+    )
+RETURN
+    DIVIDE(_CompleteRows, _TotalRows)
+```
+
+### Duplicate Detection
+
+```dax
+Duplicate_Orders =
+VAR _UniqueOrders = DISTINCTCOUNT(Sales[OrderID])
+VAR _TotalRows = COUNTROWS(Sales)
+RETURN
+    IF(
+        _UniqueOrders < _TotalRows,
+        _TotalRows - _UniqueOrders,
+        0
+    )
+```
+
+### Outlier Detection
+
+```dax
+Outlier_Count =
+VAR _Avg = AVERAGE(Sales[Amount])
+VAR _StdDev =
+    SQRT(
+        AVERAGEX(Sales, POWER(Sales[Amount] - _Avg, 2))
+    )
+VAR _LowerBound = _Avg - (3 * _StdDev)
+VAR _UpperBound = _Avg + (3 * _StdDev)
+RETURN
+    COUNTROWS(
+        FILTER(
+            Sales,
+            Sales[Amount] < _LowerBound || Sales[Amount] > _UpperBound
+        )
+    )
+```
+
+---
+
+## Conditional Logic Patterns
+
+### SWITCH with Catch-All
+
+```dax
+-- Always include default case
+Region_Group =
+SWITCH(
+    SELECTEDVALUE(Geography[Country]),
+    "USA", "North America",
+    "Canada", "North America",
+    "Mexico", "North America",
+    "UK", "Europe",
+    "Germany", "Europe",
+    "France", "Europe",
+    "Other"  -- Catch-all for unknown values
+)
+```
+
+### SWITCH TRUE Pattern
+
+```dax
+-- Complex conditional with error handling
+Performance_Level =
+VAR _Value = [Sales_vs_Target]
+RETURN
+    SWITCH(
+        TRUE(),
+        ISBLANK(_Value), "No Data",
+        ISERROR(_Value), "Error",
+        _Value >= 1.2, "Exceeds",
+        _Value >= 1.0, "Meets",
+        _Value >= 0.8, "Below",
+        _Value < 0.8, "Critical",
+        "Unknown"  -- Should never reach here
+    )
+```
+
+### Nested IF vs SWITCH
+
+```dax
+-- Prefer SWITCH for multiple conditions
+-- Less error-prone than nested IFs
+Status_SWITCH =
+SWITCH(
+    TRUE(),
+    [DaysOverdue] > 90, "Critical",
+    [DaysOverdue] > 60, "Severe",
+    [DaysOverdue] > 30, "Warning",
+    [DaysOverdue] > 0, "Overdue",
+    [DaysOverdue] = 0, "Due Today",
+    "On Track"
+)
+```
+
+---
+
+## Debug Measures
+
+### Show Calculation Context
+
+```dax
+-- Debug: Show current filter context
+Debug_Context =
+"Products: " & COUNTROWS(Products) &
+" | Dates: " & COUNTROWS('Date') &
+" | Filtered: " & IF(ISFILTERED(Products), "Yes", "No")
+```
+
+### Trace Measure Calculation
+
+```dax
+-- Debug: Step-by-step calculation
+Debug_Calculation =
+VAR _Step1 = SUM(Sales[Quantity])
+VAR _Step2 = AVERAGE(Sales[UnitPrice])
+VAR _Step3 = _Step1 * _Step2
+VAR _Step4 = DIVIDE(_Step3, 100)
+RETURN
+    "Qty:" & _Step1 &
+    " | AvgPrice:" & _Step2 &
+    " | Product:" & _Step3 &
+    " | Result:" & _Step4
+```
+
+### Validate Intermediate Results
+
+```dax
+-- Production measure with validation
+Revenue_Validated =
+VAR _Quantity = SUM(Sales[Quantity])
+VAR _Price = AVERAGE(Sales[UnitPrice])
+VAR _Result = _Quantity * _Price
+RETURN
+    IF(
+        _Quantity < 0 || _Price < 0,
+        ERROR("Negative values detected in Revenue calculation"),
+        _Result
+    )
+```
+
+---
+
+## Best Practices
+
+### 1. Always Use DIVIDE
+
+```dax
+-- Never do this
+Bad_Ratio = [Sales] / [Customers]
+
+-- Always do this
+Good_Ratio = DIVIDE([Sales], [Customers])
+```
+
+### 2. Validate Before Calculate
+
+```dax
+-- Check inputs before complex calculation
+Complex_Result =
+IF(
+    ISBLANK([Input1]) || ISBLANK([Input2]) || [Input2] = 0,
+    BLANK(),
+    [ComplexCalculation]
+)
+```
+
+### 3. Use Variables for Intermediate Checks
+
+```dax
+-- Capture values once, validate, then calculate
+Safe_Growth =
+VAR _Current = SUM(Sales[Amount])
+VAR _Prior = [Sales_PY]
+RETURN
+    IF(
+        ISBLANK(_Current) || ISBLANK(_Prior) || _Prior = 0,
+        BLANK(),
+        DIVIDE(_Current - _Prior, _Prior)
+    )
+```
+
+### 4. Handle Edge Cases Explicitly
+
+```dax
+-- Consider all scenarios
+Date_Status =
+VAR _Date = SELECTEDVALUE(Sales[DueDate])
+VAR _Today = TODAY()
+RETURN
+    SWITCH(
+        TRUE(),
+        ISBLANK(_Date), "No Due Date",
+        _Date < DATE(1900, 1, 1), "Invalid Date",
+        _Date > DATE(2100, 12, 31), "Invalid Date",
+        _Date < _Today, "Past Due",
+        _Date = _Today, "Due Today",
+        _Date <= _Today + 7, "Due This Week",
+        "Upcoming"
+    )
+```
+
+---
+
+## Error Prevention Checklist
+
+| Issue | Prevention |
+|-------|------------|
+| Division by zero | Use DIVIDE() |
+| Blank values | ISBLANK() checks, COALESCE() |
+| Missing data | SELECTEDVALUE with alternate |
+| Invalid dates | Date range validation |
+| Context errors | HASONEVALUE, ISFILTERED |
+| Type mismatches | Explicit conversions |
+| Calculation errors | IFERROR wrapper |
+| Edge cases | SWITCH TRUE with default |