Episode Details

Most organizations believe modern platforms like Microsoft Fabric made SQL optional. This episode explains why that belief is dangerously wrong. T-SQL didn’t disappear—it moved upstream, into the layer where cost overruns, security drift, performance incidents, and audit findings are created long before anyone notices them. “Beyond SELECT” doesn’t mean beyond SQL; it means beyond responsibility. This episode reframes T-SQL as what it really is in modern data platforms: a contract language for enforcing intent—truth, access boundaries, and predictable compute—in systems that otherwise drift into entropy. If your cloud costs feel random, your dashboards disagree, or your security model depends on “temporary exceptions,” this episode explains why. What You’ll Learn 1. Why “Beyond SELECT” Is About Responsibility, Not Features Modern data stacks optimize for convenience and throughput, not intent. Without explicit relational contracts—schemas, constraints, permissions, and validation—data becomes negotiable, not deterministic. 2. How SQL Actually Executes (and Why It Breaks Expectations) SQL reads like English but executes like a compiler. Understanding true execution order explains:

• Why TOP doesn’t make queries cheaper
• Why joins multiply cost
• Why filtering late creates invisible IO bills

Execution plans—not query text—are the real truth. 3. Execution Plans as Governance, Not Troubleshooting Execution plans forecast cost, risk, and blast radius. This episode reframes plans as governance artifacts:

• Estimated vs actual plans
• Why scanned vs returned rows matter
• How spills, sorts, and join choices predict incidents

A plan you can’t predict is a budget you can’t control. 4. Fabric Entropy: When Lakehouse Inputs Become Warehouse Liabilities Schema-on-read without enforcement becomes schema-never. The result:

• Dirty data silently loads
• Fixes spread into Power BI, DAX, Power Query
• Multiple “truths” emerge

T-SQL constraints and validation gates stop chaos at the boundary—before it becomes a BI argument. 5. Parameter Sniffing: Your Cloud Bill’s Favorite Feature Stable code can still produce unstable cost. This episode explains:

• Why parameter sniffing creates “random” slowdowns
• How cached plans turn historical samples into policy
• Trade-offs between recompilation, plan generalization, and branching

The goal isn’t fast queries—it’s stable ones. 6. Security Debt in Fabric: Always On ≠ Always Correct Workspace roles are not data contracts. Without database-layer permissions:

• Least privilege erodes
• Audit answers become vague
• Temporary access becomes permanent

T-SQL schemas, roles, and deny-by-default design are what make security survivable. 7. Business Logic Drift: The Quiet Killer When logic lives in Power BI, pipelines, notebooks, and apps simultaneously:

• Trust erodes
• Performance degrades
• Audits become theater

Centralizing logic in views and stored procedures turns definitions into enforceable contracts. 8. Indexing, Partitioning, and Structural Redesign You’ll learn when:

• Indexing fixes access-path problems
• Partitioning enforces storage-level discipline
• Query tuning stops working and redesign is required

Not every problem is a query problem—some are system-shape problems. 9. AI & Copilot SQL: Speed Without Governance AI writes queries instantly—but not contracts. This episode explains:

• Why AI-generated SQL accelerates entropy
• Common AI failure modes (non-sargable filters, bad joins, SELECT *)
• How execution plans become acceptance gates for AI output

AI drafts. Humans govern. Core Takeaway T-SQL isn’t about retrieving data. It’s about enforcing intent. In Fabric-era platforms, systems decay unless governed. T-SQL remains the control surface where shape, access, and cost become enforceable—befor