Blog

SQL ConstantCare® Population Report: Spring 2026

Last Updated April 21, 2026

It’s time for our quarterly update of our SQL ConstantCare® population report, showing how quickly (or slowly) folks adopt new versions of SQL Server. There were only slight 1-2% shifts, nothing big:

SQL Server 2025: 1%
SQL Server 2022: 31%, up 2% from last quarter
SQL Server 2019: 42%, down 1%
SQL Server 2017: 9%, no change
SQL Server 2016: 9%, down 1%
SQL Server 2014 & prior: 6%, no change
Azure SQL DB and Managed Instances: 2%, no change

SQL Server 2025’s 1% adoption rate might sound small, but it mirrors the adoption rate curves of 2019 and 2022 when those releases came out. It took 2019 a year to break 10% adoption, and it took 2022 a year and a half. I’ve grouped together 2014 & prior versions because they’re all unsupported, and 2016 will join them quickly in July when it goes out of extended support. (I can’t believe it’s been almost 10 years already!) Here’s how adoption is trending over time, with the most recent data at the right:

The new stuff continues its steady push from the top down, driving down the old versions out of support.

How big are the servers out there?

How much total data is on each of the monitored servers?

< 50GB: 31%
50-250GB: 23%
250GB-1TB: 23%
1-3TB: 12%
>3TB: 11%

For a long time, the measure of a “very large database” was around 1 billion rows or 1 terabyte. These days, 23% of all SQL Servers out there have over 1TB, and 1 in 10 are over 3TB! Those numbers aren’t all that big in the grand scheme of things these days. Our jobs just keep getting more challenging as organizations continue to gather more data, and hold off on archival or purging. Some of the other interesting big numbers: we’ve got servers in the audience with >400TB data, 128-448 CPU cores, 2-6TB RAM, and thousands of databases. Y’all are putting that data to work!

There’s a Bug in sys.dm_exec_query_plan_stats.

Last Updated April 21, 2026

Brent Ozar

SQL Server 2025

When you turn on last actual plans in SQL Server 2019 and newer:

ALTER DATABASE SCOPED CONFIGURATION SET LAST_QUERY_PLAN_STATS = ON;

1	ALTER DATABASE SCOPED CONFIGURATION SET LAST_QUERY_PLAN_STATS = ON;

The system function sys.dm_exec_query_plan_stats is supposed to show you the last actual query plan for a query. I’ve had really hit-or-miss luck with this thing, but my latest struggle with it is that two of the numbers are flat out wrong. It mixes up CPU time and elapsed time.

Here’s a simple query to prove it:

SET STATISTICS TIME ON;

SELECT TOP 101 value
FROM GENERATE_SERIES(-10000000, 10000000)
ORDER BY 1 DESC;

SET STATISTICS TIME OFF;

SET STATISTICS TIME ON;

SELECT TOP 101 value

FROM GENERATE_SERIES(-10000000, 10000000)

ORDER BY 1 DESC;

SET STATISTICS TIME OFF;

That query goes parallel, burns a lot of CPU, and finishes in a few seconds:

 SQL Server Execution Times:
   CPU time = 7467 ms,  elapsed time = 3106 ms.

1 2	SQL Server Execution Times: CPU time = 7467 ms, elapsed time = 3106 ms.

CPU time is higher than elapsed time, indicating that the query went parallel across multiple cores. The SET STATISTICS TIME numbers are correct, as are the time numbers in the actual query plan.

But if you check the last “actual” query plan in sys.dm_exec_query_plan_stats:

WITH XMLNAMESPACES (DEFAULT 'http://schemas.microsoft.com/sqlserver/2004/07/showplan')
SELECT  stmt_text             = SUBSTRING(st.text,
                                          (qs.statement_start_offset/2) + 1,
                                          ((CASE qs.statement_end_offset
                                                WHEN -1 THEN DATALENGTH(st.text)
                                                ELSE qs.statement_end_offset
                                            END - qs.statement_start_offset)/2) + 1),
        truth_cpu_ms          = qs.last_worker_time  / 1000,
        truth_elapsed_ms      = qs.last_elapsed_time / 1000,
        plan_xml_CpuTime      = qps.query_plan.value('(//QueryTimeStats/@CpuTime)[1]',     'bigint'),
        plan_xml_ElapsedTime  = qps.query_plan.value('(//QueryTimeStats/@ElapsedTime)[1]', 'bigint'),
        plan_xml              = qps.query_plan
FROM    sys.dm_exec_query_stats                            qs
        CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle)    st
        CROSS APPLY sys.dm_exec_query_plan_stats(qs.plan_handle) qps
WHERE   st.text LIKE '%GENERATE_SERIES(-10000000, 10000000)%'
  AND   st.text NOT LIKE '%dm_exec_query_plan_stats%';

WITH XMLNAMESPACES (DEFAULT 'http://schemas.microsoft.com/sqlserver/2004/07/showplan')

SELECT stmt_text = SUBSTRING(st.text,

(qs.statement_start_offset/2) + 1,

((CASE qs.statement_end_offset

WHEN -1 THEN DATALENGTH(st.text)

ELSE qs.statement_end_offset

END - qs.statement_start_offset)/2) + 1),

truth_cpu_ms = qs.last_worker_time / 1000,

truth_elapsed_ms = qs.last_elapsed_time / 1000,

plan_xml_CpuTime = qps.query_plan.value('(//QueryTimeStats/@CpuTime)[1]', 'bigint'),

plan_xml_ElapsedTime = qps.query_plan.value('(//QueryTimeStats/@ElapsedTime)[1]', 'bigint'),

plan_xml = qps.query_plan

FROM sys.dm_exec_query_stats qs

CROSS APPLY sys.dm_exec_sql_text(qs.sql_handle) st

CROSS APPLY sys.dm_exec_query_plan_stats(qs.plan_handle) qps

WHERE st.text LIKE '%GENERATE_SERIES(-10000000, 10000000)%'

AND st.text NOT LIKE '%dm_exec_query_plan_stats%';

The numbers are exactly backwards:

The last “actual” plan says the query took 8 seconds (it didn’t) and that it burned less CPU time than elapsed time. The numbers are just transposed.

I’ve filed a bug about this, but this is where it gets tricky as a script author. Sure, for now, I can simply reverse the numbers in my First Responder Kit scripts, fixing Microsoft’s error, but … now I gotta watch every upcoming set of Cumulative Update notes, reading to see if they fixed the bug, then go back to any relevant scripts, put in build number checking, and flip the math for the corrected builds.

Building My Dev/Prod Demon Hunters Session, Part 2: The Tactics

Last Updated April 20, 2026

Brent Ozar

First Responder Kit

This week at the SQLBits conference in Newport, I’m teaching an all-new all-day session called Dev-Prod Demon Hunters: Finding the Real Cause of Production Slowness.

It filled up initially, but they’ve opened up more seats for it, so if you’re interested, there’s still time to join! Attendees get a free Fundamentals & Mastering 1-Year Bundle. Register now for SQLBits, or if you’re already registered, email contactus@sqlbits.com to get into my workshop.

I’ve already written about how I designed the session’s strategy. My overall strategy was to set up 2 SQL Servers, then step through several different queries, each facing a different reason why they were fast on one server, slow on another server. For example, we might face issues with parameter sniffing, different statistics on each server, and different settings on each server.

Now, tactically, how do I teach each specific lesson?

There are a bunch of ways teachers can communicate a topic, like:

PowerPoint slides
A process checklist, like my D.E.A.T.H. Method from Mastering Index Tuning
Live hands-on demos in SSMS, stepping through a script or writing it on the fly
Demos, but done via stepping through slides or recordings
Handouts (like the 8KB pages I use in How to Think Like the Engine)
Physical objects (like I did with my 20-minute fragmentation demo at Bits or my statistics with playing cards demo)

Or, perhaps one of the hardest ways: give attendees an already-built tool that does the work for them. I’ve done this in the past when I unveiled sp_BlitzFirst at the PASS Summit (then called sp_AskBrent, and since renamed), live for the first time in front of the audience, springing it on ’em.

Giving them a tool is hard because:

You really gotta write the entire session first as the specs for the tool, because the tool has to deliver on what the session training was supposed to be all about
You gotta write the tool – although these days with Claude Code, that’s way easier
Then you gotta rewrite the session based on how you accomplish the goal using the tool

Building a tool is also hard because I’m basically automating myself out of some work. If I tell you how to do something really complex, then I can sell hours of training material on that, and you walk out of that class feeling like you learned a big quantity of information.

You don’t necessarily work faster that way though.

The more I worked on the Dev-Prod Demon Hunters workshop, the more clear it became that we, as an industry, really need a tool to make this easier. Before building the tool, I’d written out a giant troubleshooting checklist telling the audience all these places they needed to go to investigate these performance-killing demons. The better the session became, the more fleshed-out this checklist became, and it just isn’t realistic to expect performance tuners to look at:

sys.configurations
Database-scoped options
Trace flags
Query plan contents to see which histograms were used for estimation
Histograms for all of those statistics to see if they’re different
Last actual query plans to compare wait stats, spills, CPU metrics
Different indexes & indexed views present on each server
Different hardware capabilities
And oh yeah, parameters used to compile the plans

So onstage Wednesday, I’ll unveil the tool for the first time and teach the audience how to use it. See you there!

[Video] Office Hours in the Vegas Home Office

Last Updated April 13, 2026

Brent Ozar

Videos

When you’ve got questions about architecture, development, or best practices, post ’em at https://pollgab.com/room/brento, and upvote the ones you’d like to see me cover. It’s like free bite-sized consulting.

Here’s what we covered this week:

00:00 Start
01:37 DBAInAction: Hi Brent, could you please suggest an archival/purging strategy for multi-TB tables to free up disk space? Also, is there a recommended method for designing archiving/purging process for new databases before they become too large? Thank you!
03:47 MyTeaGotCold: I was surprised that Mastering Server Tuning never mentioned what you can do with files and filegroups in user databases. Do you find that they solve problems for you?
06:52 Forgetful: Do you ever recommend putting the tempdb log file on a different drive to the tempdb data files?
07:42 Adrian: Hi, would you enable tempdb ADR by default for new SQL 2025 servers? Any risks or negatives to consider, especially in combination with Availability Groups?
11:12 Dopinder: For SQL Server multi tenancy, one database per account seems optimal in limiting potential future corruption. However, doesn’t SQL AG tip over in the one database per account model due to AG database count limits?
13:40 FrugalShaun: What’s your go-to stat for measuring SQL Server throughput? When I want a quick comparison with past performance I check Batch Requests/sec, but that shows requests received, not necessarily work actually completed. What do you rely on instead?
15:02 Micen1: I have a customer running MDS on SQL 2019, they are looking to be able to run it on Azure SQL db but it seems that the MDS app still needs IIS on a vm? Do you the future of MDS or could you give your thoughts abouts its future and what to expect?

Updated First Responder Kit and Consultant Toolkit for April 2026

Last Updated April 13, 2026

Brent Ozar

First Responder Kit Updates

If there was ever a release you should skip for reliability reasons, it’s this one. There’s a lot of AI-edited code in here. I’m really only putting it out there because I want to let early adopters start playing around with a few new things:

sp_BlitzIndex adds an @AI parameter to get index consolidation advice for a single table.
A breaking change in the AI config tables for sp_BlitzCache (and now, sp_BlitzIndex as well.) We used to have both the AI providers and prompts in the same table, but I needed to normalize that out into two tables now that we’re adding AI capabilities to more procs. If you’ve started playing around with sp_BlitzCache’s AI config table, run this script to migrate your configs to the new table structure before running the new version of sp_BlitzCache.
Added a new SQL Server Setup Checklist markdown file in the Documentation folder. This replaces the old PDF doc that we used to distribute, but it hadn’t been updated in years. I did a quick pass with some basic updates, and folks are welcome to add their own guidance. Just create a Github issue first describing the kinds of changes you’d like to make so that you can have a community discussion about the guidance – I wanna make sure the right stuff ends up in there.
There’s a new sp_kill stored procedure, driven by your design ideas. I’ll be blogging more about this in the coming weeks, but wanted to get the first draft out there for a client who needed it ASAP. You’re welcome to use it now, and log any issues you find with it.
Starting with this release, we only support SQL Server 2016 SP2 & newer. Remember, even SQL Server 2016 drops out of support in 3 months, and 2014’s been out of support for 2 years. If you need to tune your Antiques Roadshow servers, use the scripts in the Deprecated folder. Why SP2 and not RTM or SP1? Because SP2 added a ton of DMVs and columns in existing DMVs.

To see how these work, read the documentation. In the coming weeks, I’ll be updating my (still free!) class, How I Use the First Responder Kit, with details on the AI calls and sp_kill.

To get the new version:

Download the latest FirstResponderKit.zip
Download the latest Consultant Toolkit to quickly export the First Responder Kit results into an easy-to-share spreadsheet, or import into a database
PowerShell users: run Install-DbaFirstResponderKit from dbatools

sp_Blitz Changes

Fix: wrap sp_Blitz, sp_BlitzIndex, sp_BlitzAnalysis, and sp_DatabaseRestore stored proc contents in a BEGIN and END to make it easier to automate updates to the Consultant Toolkit. (#3851)
Fix: code modernization for SQL Server 2016 & newer. (#3872)

sp_BlitzCache Changes

Enhancement: return oversized >128 node plans inline instead of asking the user to run a separate query. (#3868, thanks Erik Darling.)
Enhancement: add per-database warnings for duplicate and single-use plans to help narrow down which apps are causing the problems. (#3878, thanks Erik Darling.)
Fix: wrong parameter name in readme.md fixed. (#3861, thanks Ioan Podaru.)
Fix: skip @AI = 1 calls when query plan is null, and allow @AI = 2 to build a prompt even when there’s no query plan, just a query text. (#3855 and #3854)
Fix: invalid column reference in AI-generated code. (#3880, thanks shekarkola.)
Fix: code modernization for SQL Server 2016 & newer. (#3870)

sp_BlitzIndex Changes

Enhancement: AI advice available at the table detail level. When calling sp_BlitzIndex @TableName = ‘mytable’, you can use the @AI = 2 parameter to get an AI prompt for your favorite LLM, or @AI = 1 to call the LLM directly as we do with sp_BlitzCache. (#3827)
Fix: code modernization for SQL Server 2016 & newer. (#3876)

sp_BlitzLock Changes

Fix: corrected deadlock numbering errors. (#3859, thanks Vlad Drumea.)
Fix: avoid duplicate rows in result sets. (#3765, thanks Tisit.)
Fix: nicer error messages in Azure SQL DB that include instructions on creating an event session. (#3892)

sp_BlitzWho Changes

Fix: code modernization for SQL Server 2016 & newer. (#3874)

sp_kill Changes

First version! See the documentation for more details. (#3864)

Consultant Toolkit Changes

If you’re a consultant that does long term work, maintaining a client’s SQL Servers, then you probably want to track the health and performance of those servers over time. You want data – in a database.

We’ve got a new Loader app that watches a folder for incoming zip files, and when one shows up, it processes the data to load it into a SQL Server (or Azure SQL DB) repository for you.

This means you can set up the Consultant Toolkit at your clients on a scheduled daily task, upload the data to S3 (built in) or use your own file sync methods to get it to the location of your choosing, and then have the data automatically loaded into your database server for you.

To learn more about that, read the PDF documentation included with the Consultant Toolkit.

We’ve also added a new separate Consultant Toolkit download for SQL Server 2012-2014. Microsoft no longer supports those versions, so we’re not making changes to it anymore. It still works just the same as it always did – it just doesn’t have the cleaner code and additional diagnostics that we’re adding to the newer versions, starting this month.

For Support

When you have questions about how the tools work, talk with the community in the #FirstResponderKit Slack channel. Be patient: it’s staffed by volunteers with day jobs. If it’s your first time in the community Slack, get started here.

When you find a bug or want something changed, read the contributing.md file.

When you have a question about what the scripts found, first make sure you read the “More Details” URL for any warning you find. We put a lot of work into documentation, and we wouldn’t want someone to yell at you to go read the fine manual. After that, when you’ve still got questions about how something works in SQL Server, post a question at DBA.StackExchange.com and the community (that includes me!) will help. Include exact errors and any applicable screenshots, your SQL Server version number (including the build #), and the version of the tool you’re working with.

Announcing the Panel Lineup for My SQLBits Cloud Discussion

Last Updated April 13, 2026

Brent Ozar

Cloud Computing, SQLBits

At SQLBits, I’m hosting a panel discussion called 20 Years of the Cloud: What Changed, What Didn’t, and What’s Next. I’m excited to share the panel lineup – all of the links go to their LinkedIn profiles:

Amy Abel – aka the Database Reliability Spotter and a senior consultant at Straight Path.
Ásgeir Gunnarsson – consultant at Data Lab ApS, leader of the Icelandic PASS and Power BI groups.
Kellyn Gorman – aka DBAKevlar, engineer and advocate at Redgate Software with experience across all kinds of vendors.
Niko Neugebauer – aka NikoPort, associate director for data & analytics at Finsolutia, former Microsoftie.
Tracy Boggiano – senior SQL developer at Abarca Health, longtime blogger and presenter, and very active in many communities.

I’m excited because the panelists have a diverse set of experiences. Across the group, they’ve seen the cloud from its infancy 20 years ago, to its current state, and their visibility across a lot of companies and industries means they’re better equipped to see what’s coming next.

I’ll be asking them questions like:

What misunderstandings do executives or application teams still have about what cloud means for database performance and operations?
Has cloud improved collaboration between dev, ops, and data teams, or just created new boundaries and blame patterns?
What’s something that younger data professionals take for granted today that used to be a slow, painful process?
If you had to point to one area where cloud delivered beyond expectations, what would it be? What about under-delivered?
Looking ahead, which current cloud trends feel foundational, and which are just fashionable?
What’s a belief about cloud that you held 10 years ago, and no longer believe?
What should attendees be more skeptical about, and what should they be more optimistic about?
What skill or mindset should a data professional build now if they still want to be effective 10 years from today?
If you had to live with a system for 10 years, what choices would you make differently than if you were just trying to get it live in 3 months?

Wanna watch it unfold? Join us Thursday 10:00-10:50 in the Living Lounge. Here are calendar invite files for all of my sessions to make it easier:

Wednesday 10:40-18:00: Dev-Prod Demon Hunters – because this is an all-day workshop, you need to register for this separately. There’s space in it now because they moved the session to the auditorium, so if you wanna join and get a free Fundamentals + Mastering Bundle for a year, contact the SQLBits registration staff.
Thursday 10-10:50: 20 Years of the Cloud Panel Discussion
Friday 16:30-17:20: Watch Brent Tune a Query in SQL Server 2025
Saturday 12:20-13:10: Pokémon Battle, Choose Your Index

See you in Newport!

SQL Server 2016 Support Ends in 90 Days.

Last Updated April 14, 2026

Brent Ozar

SQL Server 2016

On July 14, 2026, Microsoft’s extended support ends for SQL Server 2016.

They will offer Extended Security Updates that you can buy for 3 more years, either through Azure or your licensing partner. The price is stunning:

Year 1, July 2026-2027: 75% of the original license price
Year 2, July 2027-2028: 150% of the original license price
Year 3, July 2028-2029: 300% of the original license price
Total for 3 years of security updates: 525% of your original license price

I didn’t know numbers went that high.

This must be that “big data” I keep hearing about. In Microsoft’s credit, I understand they’re working on an ad campaign to raise awareness, and it’ll feature Roger Allen Wade’s classic song. I’m looking forward to those commercials.

If you’re SQL Server 2016 or prior, and you’re having difficulty getting management buy-in for version upgrades, and you’re at a large enough company where you have a security team, send this in an email to your security team:

Does our tech insurance, HIPAA/PCI/SOX compliance needs, or corporate policies require us to be on currently supported software, or is it okay if we’re relying on out-of-support software that no longer gets security updates?

This lets somebody else be the bad cop, and you can connect the security team with your managers & accountants to let them duke it out. If your company doesn’t have a dedicated security team, you can send that same question to your manager, but then you’re the bad cop. That’s not nearly as much fun, but you should still probably send the email just to have something in writing to cover your rear.

Ideally, the security team and/or managers recognize the risk involved in running your shop on Antiques Roadshow software, and you start picking out which version of SQL Server you should replace it with.

If your company’s security team and/or your manager reply in writing saying no, no problems, then you’ve at least done your duty. I will say, though, that if your company is willing to be on unsupported software, they’re probably doing it to save money – and that means they’re probably also cheap on stuff like salary, employee benefits, and training. Long term, you probably wanna start passively looking for work elsewhere before your skills get as out of date as your database server. (What a dark way to end a post, eh?)

Announcing More Improvements to PasteThePlan.com

Last Updated April 11, 2026

Brent Ozar

AI, PasteThePlan.com

Need to share an execution plan, like on forums or on Stack Overflow, and you wanna get their advice as quickly as possible? Paste the XML into PasteThePlan.com and you get a link that you can share to anyone with your plan’s details.

The user interface is now cleaner, with separate tabs for query plan, query text, AI suggestions, raw XML, and your recent plans:

We noticed that a lot of people were pasting in estimated execution plans, which frankly doesn’t get you very good advice from either humans or AI. We added a warning suggesting that you paste the actual plan instead.

Note the “Delete Plan” button at the top right – that’s new too. I’d been getting more and more emails from people who realized that pasting their query plans into a web site meant that their query plans were, uh, on a web site, and I got tired of manually deleting those behind the scenes.

On the AI Suggestions tab, there’s a new feedback form so that after you try the AI’s advice, you can tell me how it did. I get notifications about the feedback, and I review it on a regular basis to help tune the prompt I send to the AI.

Finally, there’s a new “Get a Second Opinion” button at the bottom. The default first opinion is a fast, cheap call to gpt-5.4-nano that should return within 30 seconds. The second opinion calls gpt-5.4, a slower model that produces more in-depth results, but takes longer to do it (up to 3 minutes.)

I hope this helps you get more help, faster, whether that help is from your fellow humans by sharing your query plan’s link to forums and friends, or whether it’s instant free AI advice.

SQLBits Bonus: Free Fundamentals + Mastering Bundle for My Training Day Attendees

Last Updated April 10, 2026

Brent Ozar

SQLBits

Good news! My training day workshop, Dev/Prod Demon Hunters, was sold out, but Bits just moved me into the auditorium with way more capacity and space for you to stretch out.

Plus, there’s power and tables at each seat. Feel free to bring your charger, gadget, and laptop. You don’t have to follow along, but it’ll be nice for note-taking and for asking questions online, since I’ll have Pollgab up for questions so you don’t have to raise your hand and yell.

So to celebrate, I’m giving the attendees my Fundamentals & Mastering Bundle free for a year! Here’s everything you wanna know to attend.

The conference is at the International Convention Center in Newport, Wales.

Weds, 22 April: training days & general sessions, including my all-day workshop, Dev-Prod Demon Hunters: Finding the Real Cause of Production Slowness – and attendees get a free Fundamentals & Mastering Bundle
Weds evening: welcome drinks in the exhibit hall, board games night, code club
Thursday, 23 April: training days & general sessions, including my panel discussion, 20 Years of the Cloud: What Changed, What Didn’t, What’s Next
Thursday night: Pub Quiz
Friday, 24 April: training days & general sessions, including my session, Watch Brent Tune a Query in SQL Server 2025
Friday Night: the legendary SQLBits fancy dress party – this year’s theme is “cartoons”, which I also take to include anime, manga, and animation, heh
Saturday, 25 April: free day of general sessions, including my new session, Pokemon Battle, Choose Your Index: You Can’t Have Them All

SQLBits also has ticket + hotel packages for a handful of nearby hotels – expand the “Accommodation” section on that page to see the prices and hotels.

Book now here. I’ll see you in a few days! Hit reply if you’ve got any questions about how the conference works or what to expect. I’ve been there many times, and I love it.

[Video] Office Hours: Microsoft Database Q&A

Last Updated March 28, 2026

Brent Ozar

Videos

Let’s go through a LOT of your top-voted questions from https://pollgab.com/room/brento on a VERY early Saturday morning.

00:00 Start
01:52 DBAInAction: Hi Brent Microsoft just announced Automatic Index Compaction for Azure SQL and Fabric. do you see this finally killing off the traditional ‘index maintenance’ debate? Also, any gut feeling on whether this will eventually be backported to box versions of SQL Server? Thank you!
04:19 VladDBA: Hey Brent, meant to DM you but figured this fits office hours: I’m on 2-month garden leave and weighing whether to hunt for another job or launch my own consulting business. If you were in my shoes, what would you do?
06:28 Jacob H: What is everyone using for stress testing SQL Server in 2025? Looks like Microsoft has deprecated all it’s tools. (Distributed Replay and it’s replacement Replay Markup Language Utility)
09:01 EagerBeaver: hi Brent, when populating table from data from another table via INSERT INTO SELECT is there a way to OUTPUT columns that are not being inserted? I need to store mapping between old and new PK and the only way I found was to use MERGE which you don’t recommend. Thanks
10:30 Thomas Franz: Auto Create statistics is enabled on my DWH (billions of rows in partitioned Columnstore tables). When someone executes a query that uses on uncommon column first time in WHERE / JOIN it takes forever to create an execution plan. Is there a way to autocreate the stats async too?
11:56 Zale: Ola Brent, have you encountered any significant performance issues in SQL Server caused by the use of cursors?
12:37 SteveE: Hi Brent, Do you know of any resources for creating good AI prompts for query tuning? The people who appear to get the most out of AI appear to be good at writing prompts
14:57 MyTeaGotCold: Has SAN multipathing improved over the last decade? I remember when we had to be very careful with vendors not having true multipathing.
18:43 Jason Not JSON: Should we start designing schemas differently now that AI tools prefer semi-structured data like JSON?
21:11 Felipe: Hi Brent, Nowadays, do you think it’s still worth becoming or remaining a DBA specialist? Maybe this is just my impression, but I’ve been working as a DBA for over a decade (mostly with Oracle) and I’m starting to think about changing my career to another role.
23:48 .Net Dev: I’m on Azure SQL DB at compat level 140. I’ve heard you say that being “out of support” is a valid reason to upgrade. Since SQL 2017 is hitting EOL, does that logic apply to compat levels in Azure? Or is it fine to stay on 140 indefinitely if I have no performance issues?
24:36 Andrew G: I am SaaS support. I work with VMs and SQL server. Why do t-logs, if not properly maintained, affect memory / cause timeouts? Is this something to do with TempDB? If you could let me know if you have a course that covers, this currently working through fundamentals! TY !
27:59 Dopinder: We have many old sp’s that reference no longer existent columns but fortunately these sp’s are no longer used. Is there a good way to force a recompile for all sp’s so that we can identify these crusty / old sp’s that error on recompile so we can delete? SQL 2019
29:16 Matteo: Hi Brent, I just finished the ‘Faster, cheaper, cloud databases’ module. How much do you think the recent price increases for physical RAM and SSDs will impact the way we evaluate the cost-effectiveness of cloud VMs?
32:21 YouTubeFreeLoader: As a query tuner, how do you address or identify performance issues that might be a data issue in a system you aren’t familiar with. For example, a query suddenly performing worse but the root cause is a data issue like a job isn’t running that should be but you don’t know it.
34:50 How Did I Even Get Here: Just an update. I recently asked for ideas on choosing a pet project (don’t worry, during work hours). I set up a CMS to deploy/run sp_Blitz and its friends across 12 servers from my CMS and collect data in a table on the CMS. It’s AMAZING! Is this still rare, and if so, why?
38:19 Josef: How do you index for a WHERE condition with LIKE ‘%’ + @SearchText + ‘%’?
40:06 chris: Howdy, Brent! When working with a client to resolve a problem they’ve brought to you, how much time would you say you spend on documentation after you’ve landed on a solution?
43:35 DickBowen: Is using DBCC SHOW_STATISTICS to extract the histogram information into a temporary table for a lookup of RANGE_HI_KEY values a good idea?

Contest: Make the Comments Look Like My ChatGPT History.

Last Updated April 17, 2026

Brent Ozar

AI, Humor

Let’s have some fun.

Put yourself in the frame of mind of the fella who writes this blog.

What do you think I send to ChatGPT?

In the comments, write prompts that you think I’m sending to the giant robots. In one week (on April 15), I’ll go through ’em and pick my favorites. My top 3 favorites will get a Fundamentals & Mastering Bundle, and 5 honorable mentions will get the Fundamentals.

Update: the contest is over.

How Multi-Column Statistics Work

Last Updated April 7, 2026

Brent Ozar

Statistics

The short answer: in the real world, only the first column works. When SQL Server needs data about the second column, it builds its own stats on that column instead (assuming they don’t already exist), and uses those two statistics together – but they’re not really correlated.

For the longer answer, let’s take a large version of the Stack Overflow database, create a two-column index on the Users table, and then view the resulting statistics:

DropIndexes;
GO
CREATE INDEX Location_Reputation
    ON dbo.Users(Location, Reputation);
GO
DBCC SHOW_STATISTICS('dbo.Users', 'Location_Reputation');
GO

DropIndexes;

CREATE INDEX Location_Reputation

ON dbo.Users(Location, Reputation);

DBCC SHOW_STATISTICS('dbo.Users', 'Location_Reputation');

The output of DBCC SHOW_STATISTICS shows that we’ve got about 22 million rows in this table. So, what does the statistics histogram say about the relationships between locations and reputations?

In the first result set, you can see that Rows = 22,484,235, and Rows Sampled = 22,484,235 – the same number. That means our statistics had a full scan, which is as good as they can possibly get.

The density vectors aren’t very useful.

The second result set are the density vectors – aka, the averages – and it has 3 rows. The first one says Location: all density = 3.282714E-06. If you take that number, times 22,484,235, you get 73.8093. That’s the density vector: if SQL Server needs to estimate how many rows are going to match for a given location, and it doesn’t know what the location is, it’ll estimate 73.8093.

Here’s an example query to prove that. I’m using a local variable to prevent SQL Server from sniffing the value, so it’ll have no idea what the @LocationUnknown value will be at compilation time:

DECLARE @LocationUnknown 
    NVARCHAR(200) = N'Las Vegas, NV';

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = @LocationUnknown;

DECLARE @LocationUnknown

NVARCHAR(200) = N'Las Vegas, NV';

SELECT COUNT(*) FROM dbo.Users

WHERE Location = @LocationUnknown;

In the resulting query plan:

When you hover your mouse over the index seek and look at “Estimated Number of Rows Per Execution”, you get 73.8093:

Back to our DBCC SHOW_STATISTICS output. We explained that the first row was the density vector for Location alone – so what’s the second row, which says Location, Reputation?

What’s that “1.058257E-06” number mean in the Location, Reputation column? Multiply that by the number of rows in the table (22,484,235) and you get 23.794. I bet you can see where I’m going with this:

DECLARE @LocationUnknown NVARCHAR(200) = N'Las Vegas, NV',
        @ReputationUnknown INT = 1234;

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = @LocationUnknown
AND Reputation = @ReputationUnknown;

DECLARE @LocationUnknown NVARCHAR(200) = N'Las Vegas, NV',

@ReputationUnknown INT = 1234;

SELECT COUNT(*) FROM dbo.Users

WHERE Location = @LocationUnknown

AND Reputation = @ReputationUnknown;

Here’s our query plan, and bingo, 23.794 estimated rows:

If you’re searching for an unknown (or unpredictable before runtime) location and reputation combo, SQL Server uses the density vector in the histogram to calculate how many rows are going to match. SQL Server thinks that for any given location and reputation, no matter what values you pass in, they’re going to produce 23.7941.

At first, that sounds ridiculous: Reputation is an integer number. If you’re asking for equality searches on that number, and you’re passing in random numbers, there’s practically no way that estimate could be right. On “average”, maybe across thousands or millions of searches, this could be vaguely the average number – but it’s never going to be correct. It’s going to be wildly overestimated some times, and wildly underestimated at other times.

But what about the histogram?

The next result set in DBCC SHOW_STATISTICS is the histogram, which contains the detailed list of up to 201 location values – because Location is the first column in our statistic:

Let’s scroll down to the Vegas area:

Las Vegas isn’t big enough of an outlier to get its own bucket, so if we query for the people who live in Las Vegas:

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = N'Las Vegas, NV' AND 1 = (SELECT 1);

1 2	SELECT COUNT(*) FROM dbo.Users WHERE Location = N'Las Vegas, NV' AND 1 = (SELECT 1);

Note that I’m using 1 = (SELECT 1) in order to prevent autoparameterization, which is a totally different subject for another day. Hover our mouse over the execution plan to see the estimated number of rows:

The 7.04485 estimate comes from our statistics. Scroll back up a couple of images, and note that in our statistics, I highlighted the row for Lebanon. “Las Vegas, NV” is somewhere between “Lahore, Pakistan” and “Lebanon” (it certainly feels that way on the highway sometimes), so SQL Server uses the AVG_RANGE_ROWS number of 7.044848.

When SQL Server is searching for an unknown Location, it uses the density vector. When it’s searching for a known location in between two range high keys, it uses the AVG_RANGE_ROWS number. So far, so good.

But what happens if we pass in a search for a known location AND a known reputation?

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = N'Las Vegas, NV' 
AND Reputation = 1234
AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'Las Vegas, NV'

AND Reputation = 1234

AND 1 = (SELECT 1);

Before we look at the execution plan of that query, take a moment to review the statistics at play here. Which column is SQL Server going to use for its estimate?

Which column in the above screenshot tells SQL Server that any particular location has a higher or lower average reputation score, or how distributed the values are?

That’s right: there isn’t one!

This statistics histogram isn’t really about the second column of the object at all. It’s about the first column! Multi-column stats aren’t, really: they’re really just single-column stats!

Here’s the part that’s kinda mind-blowing. Here’s the query plan for Las Vegas and 1234:

Look familiar? That’s a 7.04485 estimate. Exactly the same as if we weren’t filtering on reputation at all. It’s using the avg_range_rows from our statistics, giving us the exact same estimate that we got from just filtering on Location = Las Vegas.

The histogram values for the first column in our object is really useful. Subsequent columns, not so much.

The Reputation value I’m searching for doesn’t really matter here either. Let’s try one of the biggest values, Reputation = 1. You’ll see why this is important later:

The estimate is still 7.04485: exactly the same as not filtering by reputation at all. That’s… not great.

Things change a little for really big outliers.

Let’s try searching for the very biggest location value: India. If we search for just the location value (not a reputation yet), the histogram is useful because India’s one of our outliers:

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = N'India' 
AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'India'

AND 1 = (SELECT 1);

The resulting execution plan estimates are absolutely bang on:

Then add in a filter for a given reputation number, and here I’m going to do both 1234 and 1 back to back:

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = N'India' 
AND Reputation = 1234
AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users 
WHERE Location = N'India' 
AND Reputation = 1
AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'India'

AND Reputation = 1234

AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'India'

AND Reputation = 1

AND 1 = (SELECT 1);

And whaddya know: now our estimates are not 7.04485, unlike Las Vegas:

SQL Server manages to figure out that India is not only huge, but also that Reputation = 1 is huge. So, how’d it do that? Right-click on the SELECT operator of the second query, go into Properties, and then OptimizerStatsUsage:

SQL Server didn’t just use the stat on Location_Reputation. In order to understand that Reputation = 1 is an outlier, it also automatically created a statistic on the Reputation column separately because the Reputation data in the Location_Reputation statistic just wasn’t useful enough.

Multi-column stats just don’t help much by themselves.

To really prove it, let’s set up an artificial scenario. Let’s say that everyone in China has really high reputation. And, just to give SQL Server the best defenses possible, let’s create a multi-column index (and therefore stat) on Reputation, Location. Hell, let’s even update statistics on Users so that our existing Location, Reputation stat completely understands that China’s where the smart people are at:

UPDATE dbo.Users SET Reputation = 1000000
WHERE Location = N'China';

CREATE INDEX Reputation_Location
    ON dbo.Users(Reputation, Location);

UPDATE STATISTICS dbo.Users WITH FULLSCAN;

UPDATE dbo.Users SET Reputation = 1000000

WHERE Location = N'China';

CREATE INDEX Reputation_Location

ON dbo.Users(Reputation, Location);

UPDATE STATISTICS dbo.Users WITH FULLSCAN;

If that was a Venn diagram, we would now have a perfect circle: all of the people in China have exactly 1,000,000 reputation points, and the only people with exactly 1,000,000 reputation points are in China:

SELECT COUNT(*) FROM dbo.Users
WHERE Location = N'China';

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000;

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000
AND Location <> N'China';

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'China';

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000;

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000

AND Location <> N'China';

The results:

So now, let’s ask SQL Server:

How many people do you THINK live in China?
How many people do you THINK have 1,000,000 reputation points?
How many people do you THINK live in China, AND have 1,000,000 points?

SELECT COUNT(*) FROM dbo.Users
WHERE Location = N'China' AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000 AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000
AND Location = N'China' AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'China' AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000 AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000

AND Location = N'China' AND 1 = (SELECT 1);

Check out the estimated number of rows on the query plans:

Or for those of you who prefer memes:

If SQL Server had anything even remotely resembling true multi-column stats, the estimate would be closer than this. We don’t, so it’s not.

The documentation suggests that you should create these statistics manually when you know there’s correlation:

CREATE STATISTICS Stat_Location_Reputation
ON dbo.Users(Location, Reputation)
WITH FULLSCAN;

CREATE STATISTICS Stat_Reputation_Location
ON dbo.Users(Reputation, Location)
WITH FULLSCAN;

DBCC FREEPROCCACHE;
GO
SELECT COUNT(*) FROM dbo.Users
WHERE Location = N'China' AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000 AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users
WHERE Reputation = 1000000
AND Location = N'China' AND 1 = (SELECT 1);

CREATE STATISTICS Stat_Location_Reputation

ON dbo.Users(Location, Reputation)

WITH FULLSCAN;

CREATE STATISTICS Stat_Reputation_Location

ON dbo.Users(Reputation, Location)

WITH FULLSCAN;

DBCC FREEPROCCACHE;

SELECT COUNT(*) FROM dbo.Users

WHERE Location = N'China' AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000 AND 1 = (SELECT 1);

SELECT COUNT(*) FROM dbo.Users

WHERE Reputation = 1000000

AND Location = N'China' AND 1 = (SELECT 1);

But yeah no, that still doesn’t work, and still produces the same 89-row estimate.

To learn how to solve these kinds of problems, check out my Mastering Query Tuning class.

Who’s Hiring Database People? April 2026 Edition

Last Updated January 15, 2026

Brent Ozar

Who’s Hiring

Is your company hiring for a database position as of April 2026? Do you wanna work with the kinds of people who read this blog? Let’s make a love connection.

If your company is hiring, leave a comment. The rules:

Your comment must include the job title, and either a link to the full job description, or the text of it.
An email address to send resumes, or a link to the application process – if I were you, I’d put an email address because you may want to know that applicants are readers here, because they might be more qualified than the applicants you regularly get.
Please state the location and include REMOTE and/or VISA when that sort of candidate is welcome. When remote work is not an option, include ONSITE.
Please only post if you personally are part of the hiring company—no recruiting firms or job boards. Only one post per company. If it isn’t a household name, please explain what your company does.
It has to be a data-related job.

If your comment isn’t relevant or smells fishy, I’ll delete it. If you have questions about why your comment got deleted, or how to maximize the effectiveness of your comment, contact me.

Each month, I publish a new post in the Who’s Hiring category here so y’all can get the latest opportunities.

SQL Server 2025 CU4 Adds Automatic Updates

Last Updated April 2, 2026

Brent Ozar

Humor

April 1, 2026: Big news for everyone who has to manage Microsoft SQL Server, whether they’re DBAs, sysadmins, or developers.

Seven years ago, Microsoft announced automatic, downtime-free hot patching of the SQL Server engine in Azure SQL DB. The tail end of that post had a teaser in it:

Well, I guess enough of you emailed in, because 7 years later, starting with Cumulative Update 4, SQL Server finally has that capability! The original technical post covers the internals of how it works, but there are a few changes for the on-premises boxed-product version of SQL Server:

SQL Server’s CEIP service (the Customer Experience Improvement Program telemetry service that constantly connects back to Microsoft’s servers) gets the list of available updates for your build. It was already sending your build number to Microsoft anyway,
SQL Server downloads the most recent available update, staging it in the binaries directory
The updates are applied based on the new sp_configure setting for ‘automatic updates’

Obviously, for safety reasons, you’re not opted into automatic updates. You have to choose when you want the binaries to be applied with that new sp_configure setting:

/* Apply updates at the next service restart: */
EXECUTE sp_configure 'automatic updates', 'on restart';

/* Apply updates immediately only if no databases are primary: */
EXECUTE sp_configure 'automatic updates', 'on secondary';

/* Apply updates at the next service restart: */

EXECUTE sp_configure 'automatic updates', 'on restart';

/* Apply updates immediately only if no databases are primary: */

EXECUTE sp_configure 'automatic updates', 'on secondary';

There are more options, similar to SQL Server 2014’s options for online index rebuilds, and I love that they used the exact same syntax to keep things simple:

/* Wait in the background, and when no queries are running, 
apply updates - aka Azure SQL DB style: */
EXECUTE sp_configure 'automatic updates', 'wait at low priority';

/* Wait up to 30 minutes (or put in the integer of your choice),
and if queries are still running then, apply updates anyway: */
EXECUTE sp_configure 'automatic updates', 'max duration 30';

/* Wait in the background, and when no queries are running,

apply updates - aka Azure SQL DB style: */

EXECUTE sp_configure 'automatic updates', 'wait at low priority';

/* Wait up to 30 minutes (or put in the integer of your choice),

and if queries are still running then, apply updates anyway: */

EXECUTE sp_configure 'automatic updates', 'max duration 30';

Some of you out there are going to raise your wrinkled old hands to the sky and shake your fist angrily, cursing modern Microsoft. First, they came for your job with automatic index tuning in Azure in 2018, then brought that to the SQL Server boxed product, then automated patching in Azure SQL DB, and now they’re coming for your maintenance jobs on-premises too. That’s scary, I know, because it can feel like there’s less and less left for database administrators to do.

All we’ve got left to do with SQL Server is the initial installation, engine configuration, backups, high availability, disaster recovery, corruption checking, permissions setup, performance monitoring, query tuning, and outage troubleshooting. I don’t know how future DBAs will be able to stay busy, and they should definitely start thinking about better long term career options now that the database is self-managing and self-patching.

Note: this post was published on April 1, 2026. That date probably means something significant, given that I’ve shown it a few times on the page.

How to Draw Line Graphs in SSMS

Last Updated March 31, 2026

Brent Ozar

SQL Server Management Studio

Ever just need a quick visualization of some numbers to get a rough idea of the trend, like this:

Option 1: ask Copilot to write the query for you.

In SSMS v22.3 and newer, with the results query on your screen, open up SSMS Copilot and copy/paste this into the prompt:

Given the query in this window, graph the results as a line chart in the SSMS Spatial Results tab using these rules:

1. Wrap the original query in a CTE called SourceData

2. Create a ScaledData CTE that scales X values to 0–300 and Y values to 0–100 using window functions MIN/MAX OVER()

3. Build a LINESTRING geometry from the scaled points

4. Use STDifference to cut holes in the line where data points are, so tooltips don’t conflict

5. Use STBuffer(3) to make each data point a large circle

6. UNION ALL the line (with holes) and the circles, with the line row having NULL for all non-geometry columns

7. The first column in the SELECT should be the X-axis label, the second column should be the Y-axis measure, and the third column should be the geometry — so tooltips show meaningful data when hovering over circles

Use a large model (like Claude Opus 4.6 or newer) for the best results. It’ll write the query for you, and if you’ve been living your life right, you’ll get something like this:

-- Created by GitHub Copilot in SSMS - review carefully before executing
WITH YearlyData AS (
    SELECT 
        YEAR(CreationDate) AS Yr, 
        SUM(1) AS UsersCreated
    FROM dbo.Users
    GROUP BY YEAR(CreationDate)
),
ScaledData AS (
    SELECT 
        Yr,
        UsersCreated,
        -- Scale X: years to 0-300 range (wide)
        (Yr - MIN(Yr) OVER ()) * 300.0 / NULLIF(MAX(Yr) OVER () - MIN(Yr) OVER (), 0) AS X,
        -- Scale Y: users to 0-100 range (short)
        UsersCreated * 100.0 / NULLIF(MAX(UsersCreated) OVER (), 0) AS Y
    FROM YearlyData
),
LineGeom AS (
    SELECT geometry::STGeomFromText(
        'LINESTRING(' + 
        STRING_AGG(CAST(X AS VARCHAR(20)) + ' ' + CAST(Y AS VARCHAR(20)), ', ') 
        WITHIN GROUP (ORDER BY Yr) + 
        ')', 0) AS Geom
    FROM ScaledData
),
AllCircles AS (
    SELECT geometry::UnionAggregate(geometry::Point(X, Y, 0).STBuffer(3)) AS Geom
    FROM ScaledData
)
-- Line with holes cut out where circles are
SELECT 
    NULL AS Yr,
    NULL AS UsersCreated,
    lg.Geom.STDifference(ac.Geom) AS Geometry
FROM LineGeom lg
CROSS JOIN AllCircles ac

UNION ALL

-- Circles on top
SELECT 
    Yr,
    UsersCreated,
    geometry::Point(X, Y, 0).STBuffer(3) AS Geometry
FROM ScaledData;

-- Created by GitHub Copilot in SSMS - review carefully before executing

WITH YearlyData AS (

SELECT

YEAR(CreationDate) AS Yr,

SUM(1) AS UsersCreated

FROM dbo.Users

GROUP BY YEAR(CreationDate)

ScaledData AS (

SELECT

Yr,

UsersCreated,

-- Scale X: years to 0-300 range (wide)

(Yr - MIN(Yr) OVER ()) * 300.0 / NULLIF(MAX(Yr) OVER () - MIN(Yr) OVER (), 0) AS X,

-- Scale Y: users to 0-100 range (short)

UsersCreated * 100.0 / NULLIF(MAX(UsersCreated) OVER (), 0) AS Y

FROM YearlyData

LineGeom AS (

SELECT geometry::STGeomFromText(

'LINESTRING(' +

STRING_AGG(CAST(X AS VARCHAR(20)) + ' ' + CAST(Y AS VARCHAR(20)), ', ')

WITHIN GROUP (ORDER BY Yr) +

')', 0) AS Geom

FROM ScaledData

AllCircles AS (

SELECT geometry::UnionAggregate(geometry::Point(X, Y, 0).STBuffer(3)) AS Geom

FROM ScaledData

)

-- Line with holes cut out where circles are

SELECT

NULL AS Yr,

NULL AS UsersCreated,

lg.Geom.STDifference(ac.Geom) AS Geometry

FROM LineGeom lg

CROSS JOIN AllCircles ac

UNION ALL

-- Circles on top

SELECT

Yr,

UsersCreated,

geometry::Point(X, Y, 0).STBuffer(3) AS Geometry

FROM ScaledData;

Voila! Graph. Un-check the “Show grid lines” box on the SSMS results tab because the X/Y axis won’t make sense.

Option 2: use this user-defined function.

I asked Copilot to bundle this into a reusable piece of code so that I could use it for any query. It sets up a user-defined table type, then a function that accepts that user-defined table type as an input parameter:

-- Created by GitHub Copilot in SSMS - review carefully before executing

-- Step 1: Create user-defined table type for input data
CREATE TYPE dbo.GraphInput AS TABLE
(
    SortOrder FLOAT,       -- Controls point ordering on X-axis
    Label     NVARCHAR(100), -- Displayed in tooltip
    Measure   FLOAT          -- Y-axis value displayed in tooltip
);
GO

-- Step 2: Create the graphing function
CREATE FUNCTION dbo.fn_GraphSpatial
(
    @Data dbo.GraphInput READONLY
)
RETURNS @Result TABLE
(
    Label    NVARCHAR(100),
    Measure  FLOAT,
    Geometry geometry
)
AS
BEGIN
    DECLARE @XRange      FLOAT = 300.0;
    DECLARE @YRange      FLOAT = 100.0;
    DECLARE @CircleRadius FLOAT = 3.0;

    DECLARE @MinSort    FLOAT;
    DECLARE @SortSpan   FLOAT;
    DECLARE @MaxMeasure FLOAT;
    DECLARE @PointCount INT;

    SELECT
        @MinSort    = MIN(SortOrder),
        @SortSpan   = NULLIF(MAX(SortOrder) - MIN(SortOrder), 0),
        @MaxMeasure = NULLIF(MAX(Measure), 0),
        @PointCount = COUNT(*)
    FROM @Data;

    -- Pre-compute scaled coordinates
    DECLARE @Scaled TABLE
    (
        Label     NVARCHAR(100),
        Measure   FLOAT,
        X         FLOAT,
        Y         FLOAT,
        SortOrder FLOAT
    );

    INSERT INTO @Scaled (Label, Measure, X, Y, SortOrder)
    SELECT
        Label,
        Measure,
        CASE WHEN @SortSpan IS NULL THEN @XRange / 2.0
             ELSE (SortOrder - @MinSort) * @XRange / @SortSpan END,
        CASE WHEN @MaxMeasure IS NULL THEN 0
             ELSE Measure * @YRange / @MaxMeasure END,
        SortOrder
    FROM @Data;

    -- Insert data point circles
    INSERT INTO @Result (Label, Measure, Geometry)
    SELECT Label, Measure, geometry::Point(X, Y, 0).STBuffer(@CircleRadius)
    FROM @Scaled;

    -- Build the connecting line (2+ points required)
    IF @PointCount >= 2
    BEGIN
        DECLARE @LineWKT NVARCHAR(MAX);
        SELECT @LineWKT = 'LINESTRING(' +
            STRING_AGG(
                CAST(X AS VARCHAR(20)) + ' ' + CAST(Y AS VARCHAR(20)), ', '
            ) WITHIN GROUP (ORDER BY SortOrder) +
            ')'
        FROM @Scaled;

        DECLARE @Line geometry = geometry::STGeomFromText(@LineWKT, 0);

        -- Cut holes where circles are so tooltips don't conflict
        DECLARE @AllCircles geometry;
        SELECT @AllCircles = geometry::UnionAggregate(
            geometry::Point(X, Y, 0).STBuffer(@CircleRadius)
        )
        FROM @Scaled;

        INSERT INTO @Result (Label, Measure, Geometry)
        SELECT NULL, NULL, @Line.STDifference(@AllCircles);
    END

    RETURN;
END
GO


-- Usage example
DECLARE @data dbo.GraphInput;

INSERT INTO @data (SortOrder, Label, Measure)
SELECT
    YEAR(CreationDate),
    CAST(YEAR(CreationDate) AS NVARCHAR(100)),
    COUNT(*)
FROM dbo.Users
GROUP BY YEAR(CreationDate);

SELECT * FROM dbo.fn_GraphSpatial(@data);

100

101

102

103

104

105

106

107

-- Created by GitHub Copilot in SSMS - review carefully before executing

-- Step 1: Create user-defined table type for input data

CREATE TYPE dbo.GraphInput AS TABLE

(

SortOrder FLOAT, -- Controls point ordering on X-axis

Label NVARCHAR(100), -- Displayed in tooltip

Measure FLOAT -- Y-axis value displayed in tooltip

);

-- Step 2: Create the graphing function

CREATE FUNCTION dbo.fn_GraphSpatial

(

@Data dbo.GraphInput READONLY

)

RETURNS @Result TABLE

(

Label NVARCHAR(100),

Measure FLOAT,

Geometry geometry

)

BEGIN

DECLARE @XRange FLOAT = 300.0;

DECLARE @YRange FLOAT = 100.0;

DECLARE @CircleRadius FLOAT = 3.0;

DECLARE @MinSort FLOAT;

DECLARE @SortSpan FLOAT;

DECLARE @MaxMeasure FLOAT;

DECLARE @PointCount INT;

SELECT

@MinSort = MIN(SortOrder),

@SortSpan = NULLIF(MAX(SortOrder) - MIN(SortOrder), 0),

@MaxMeasure = NULLIF(MAX(Measure), 0),

@PointCount = COUNT(*)

FROM @Data;

-- Pre-compute scaled coordinates

DECLARE @Scaled TABLE

(

Label NVARCHAR(100),

Measure FLOAT,

X FLOAT,

Y FLOAT,

SortOrder FLOAT

);

INSERT INTO @Scaled (Label, Measure, X, Y, SortOrder)

SELECT

Label,

Measure,

CASE WHEN @SortSpan IS NULL THEN @XRange / 2.0

ELSE (SortOrder - @MinSort) * @XRange / @SortSpan END,

CASE WHEN @MaxMeasure IS NULL THEN 0

ELSE Measure * @YRange / @MaxMeasure END,

SortOrder

FROM @Data;

-- Insert data point circles

INSERT INTO @Result (Label, Measure, Geometry)

SELECT Label, Measure, geometry::Point(X, Y, 0).STBuffer(@CircleRadius)

FROM @Scaled;

-- Build the connecting line (2+ points required)

IF @PointCount >= 2

BEGIN

DECLARE @LineWKT NVARCHAR(MAX);

SELECT @LineWKT = 'LINESTRING(' +

STRING_AGG(

CAST(X AS VARCHAR(20)) + ' ' + CAST(Y AS VARCHAR(20)), ', '

) WITHIN GROUP (ORDER BY SortOrder) +

')'

FROM @Scaled;

DECLARE @Line geometry = geometry::STGeomFromText(@LineWKT, 0);

-- Cut holes where circles are so tooltips don't conflict

DECLARE @AllCircles geometry;

SELECT @AllCircles = geometry::UnionAggregate(

geometry::Point(X, Y, 0).STBuffer(@CircleRadius)

)

FROM @Scaled;

INSERT INTO @Result (Label, Measure, Geometry)

SELECT NULL, NULL, @Line.STDifference(@AllCircles);

END

RETURN;

END

-- Usage example

DECLARE @data dbo.GraphInput;

INSERT INTO @data (SortOrder, Label, Measure)

SELECT

YEAR(CreationDate),

CAST(YEAR(CreationDate) AS NVARCHAR(100)),

COUNT(*)

FROM dbo.Users

GROUP BY YEAR(CreationDate);

SELECT * FROM dbo.fn_GraphSpatial(@data);

To use it, insert your data into the user-defined table type. In this example below, I’m loading in the top 10 biggest locations in the Stack Overflow Users table:

DECLARE @data dbo.GraphInput;

WITH TopLocations AS (
    SELECT TOP 10 Location, COUNT(*) AS People
    FROM dbo.Users
    WHERE Location <> ''
    GROUP BY Location
    ORDER BY COUNT(*) DESC
)
INSERT INTO @data (SortOrder, Label, Measure)
SELECT ROW_NUMBER() OVER (ORDER BY Location) AS RankNumber,
    Location, People
FROM TopLocations
ORDER BY Location;

SELECT * FROM dbo.fn_GraphSpatial(@data);

DECLARE @data dbo.GraphInput;

WITH TopLocations AS (

SELECT TOP 10 Location, COUNT(*) AS People

FROM dbo.Users

WHERE Location <> ''

GROUP BY Location

ORDER BY COUNT(*) DESC

)

INSERT INTO @data (SortOrder, Label, Measure)

SELECT ROW_NUMBER() OVER (ORDER BY Location) AS RankNumber,

Location, People

FROM TopLocations

ORDER BY Location;

SELECT * FROM dbo.fn_GraphSpatial(@data);

And voila:

Line charts don’t make as much sense for that particular set of data – you’d probably want bar charts or column charts instead. I’ll leave that to you and your robot friend to work on.

If you wanna watch me work through this with Copilot to come up with the queries, here’s a video of me working on it. Enjoy!

And no, this isn’t my April Fool’s post, hahaha. This does actually work – although I obviously wouldn’t recommend it for any end-user-facing stuff. It’s just fun to have a nice, quick, easy visualization that you can copy/paste into emails or presentations.

I’m Coming to the PASS Summit in Frankfurt!

Last Updated March 27, 2026

Brent Ozar

#SQLPass

The pre-conference lineup for the PASS Data Community Summit Frankfurt event was just released, and I’m proud to share that I’ll be teaching my new all-day pre-conference workshop.

Dev-Prod Demon Hunters:
Finding the Real Cause of Production Slowness

Production is slow. Development is fast. The same query runs in both. Somewhere between the two, a performance demon is hiding—and this session is about hunting it down.

Your queries drive me to drink. — My own demons

Inspired by Brent Ozar’s love of the K-Pop Demon Hunters theme song, this class is delivered almost entirely as live demos, not slides. Brent Ozar will run real queries against two environments labeled “dev” and “prod,” then work through them exactly the way an experienced DBA would in the real world: comparing server settings, analyzing execution plans, and uncovering the subtle differences that led SQL Server to make different decisions. Each “hunt” reveals another demon—statistics, configuration, data distribution, or plan choice—and shows how easily a test environment can lie.

Along the way, Brent will demonstrate practical techniques you can use immediately: running sp_Blitz to surface meaningful environment differences, comparing execution plans to understand why SQL Server behaved differently, and making targeted changes to development so it better reflects production reality. By the end, you’ll understand how to stop guessing, stop blaming the engine, and follow the clues that lead to the truth—because when dev and prod finally move in sync, that’s when performance goes golden.

3 things you’ll get out of this session

Discover what caused query plans to vary from production
Learn how to quickly assess environment differences that would cause query plan changes
Understand how to change dev to more closely match prod

Pre-requisites: You should already be comfortable writing queries, reading execution plans, and using the First Responder Kit to gather data about your server’s wait stats and health.

Registration is open now with early bird pricing expiring March 31 (quickly!), and attendees will get a free year of my Recorded Class Season Pass: Fundamentals. See you in Frankfurt!

[Video] Office Hours: Q&A on the Mountaintop

Last Updated March 15, 2026

Brent Ozar

Videos

Well, maybe mountain is a bit of a strong word, but it’s one of the highest elevation home sites in Las Vegas, with beautiful views over the valley, the Strip, the airport, and the surrounding mountains. Let’s go through your top-voted questions from https://pollgab.com/room/brento while taking in the view – and you can move the camera around, since this is an Insta360 video.

I had to cut the first ~60 seconds of the intro, so it seems to start in an odd place:

Here’s what we covered:

00:00 Start
00:33 Sun Ra: Who is your favorite musician?
01:27 Dopinder: What is your opinion of the query hint tool in SSMS22? Who is the target audience? Will end users misuse it?
02:30 Trushit: I need medallion architecture for BI initiative. What would be your thought process? Largest table today is about 3M rows.
03:42 I Graduated MIT: In the MIT class, you say developers just need clustered indexes on each table (and FK) as a starting point, and DBAs take over later once it’s in production. Does AI change that? Should devs use AI to predict indexes earlier?
05:15 Bandhu: SQL log shipping performance can be bad over cloud provider SMB storage options. What’s your opinion of swapping out the default log shipping transport (SMB file copy) to using something more network efficient (Blob storage for Azure or S3 for Amazon)?
06:54 racheld933: Do you have a specific industry/sector of clients that you prefer over others? Like healthcare, finance, education, etc. Are there any specific challenges or trends that show up within each group?
08:21 RoJo: Can you comment on the use of BitLocker on a SQL server host? I’m concerned on speed, and another layer to add when patching or updating. Is it really needed if the Host is physically locked in a rack and room.
10:09 Alice: AI sent me down a powershell rabbit hole of try this, oh wait, sorry try that only to tell me many attempts later that what I was asking for is no longer supported. What is the worst AI rabbit hole you’ve experienced?
11:30 Mister Robot: At what point does “AI-assisted DBA” turn into “why do we still have DBAs?”
12:58 NicTheDataGuy: Hi Brent, you made a comment in a previous post that ” I actually put serious thought into deciding which tool I was going to learn next because I’d have so much free time”, curious what you would have done and why? is there a tool/language you think is going to be in demand?

Y’all Are Getting Good Free AI Advice from PasteThePlan.

Last Updated March 24, 2026

Brent Ozar

AI, PasteThePlan.com

PasteThePlan has a new AI Suggestions tab, and it’s been really fun to watch the query plans come in and the advice go out. Here are some examples:

Date “tables” – when I looked at the query, I glossed over the real problem. I thought arc_Calendar was a real date table, but AI figured out that it’s actually generated on the fly with spt_values, something that blows my mind at what an incredibly bad idea that is. It never crossed my mind that someone would even consider doing this in production, and AI tells them what to do instead.
This is fine – someone asked for advice on a select from a 1-row temp table. AI said get outta here with that nonsense.
One-table delete – but due to foreign keys, it’s actually touching multiple tables. The AI advice explains what’s going on and how to make it go faster, plus boils it down to “if you only do one thing” – I love that! I love prioritized advice.
Reporting process – a kitchen-sink style query that at first glance should probably be rewritten to dynamic SQL, but they’ve already solved that to some extent by slapping an option recompile hint on it. The AI advice catches a scalar UDF causing problems, suggests a rewrite using a technique the company’s already using on another column, and suggests a slight rewrite to push filtering earlier. Again, I love its recap here, all for free, in less than 30 seconds.
Lengthy paged dynamic SQL – ugh, even just glancing at this makes me look at the clock to think about how long it would take me to analyze. In seconds, AI reasoned over this monster to suggest indexes that would help the paging, plus raises some eyebrows at a weird not-exists-not-exists design.
Meaningful function rewrites – advice to quickly and easily change non-sargable functions into index seeks, and remove a correlated subquery.

Advice I’m not as wild about, and I’m thinking about how to tune the AI prompt in order to improve it:

16,000 row export with no WHERE clause – my first reaction here is to say, “Whoa now, we don’t tune for 16,000-row XML export queries.” However, when it comes to tuning the prompt to deliver better advice, I think we need to push the user harder to copy/paste in actual execution plans that include timing information, and then evaluate whether we should bother making changes, or whether the query’s performing good enough based on the wild output we’re asking for. This Power BI query is a similar example – whenever I see scientific notation for the estimated number of rows, I wanna stop tuning there and go get the actual plan.
Covering indexes galore – this is just one example, but my first iteration on my AI prompt didn’t discourage covering indexes, and AI seems to really wanna suggest ’em. I need to refine the prompt to suggest starting indexes with just the keys, and then only add includes for covering if the query’s still not fast enough after the initial indexes. There also seems to be a hesitance to recommend clustered indexes on heaps, even reporting heaps that were just created for the purpose of the query we’re looking at.
Lose the cursor – I’m surprised at how often I’ve seen folks paste cursor plans in. I do love the advice – it’s always “hey lose the cursor” – but I think we could do better. I’d like to be able to proactively rewrite stuff for folks, but realistically, a web page isn’t the best UI for that, and it will probably need a better, slower model with a >30 second timeout. We need to tell people, “Here’s a link to a set of commands that will rewrite the query for you” – whether that’s Claude Code, ChatGPT Codex, the plain chat interface for those tools, or something else.

And some queries & advice are just making me think. For example, in this multi-step reporting query, the AI seemed to find a lot of advice, but to understand if the advice is any good, I kinda want a followup status report from the user. Did they implement any of these fixes? Which ones? What kinds of differences did they see? We probably need a feedback loop of some kind to help iterate over the AI prompt.

I’m not delusional enough to think PasteThePlan.com is the right long-term solution for getting plan advice! We only have about 50 people using it each weekday. However, if that helps 50 people per day avoid posting questions to forums, and get instant answers that solve their problems for free and make users happier, then I’m very happy with that result. I couldn’t possibly answer 50 peoples’ query questions per day for free in my spare time!

My Wish List for SQL Server Performance Features

Last Updated March 12, 2026

Brent Ozar

SQL Server vNext

There are a lot of shopping days left before Christmas, and even more before the next version of SQL Server ships, so might as well get my wish list over to Santa now so the elves can start ~~working on~~ ignoring them.

My work focuses on performance tuning, so that’s what my wish list focuses on, too. They really are wishes, like I-want-a-pony, because I know I’m discussing some stuff that’s easy to describe, but really challenging to implement.

Forced Parameterization v2: The original implementation of this feature helped mitigate the multiple-plans-for-one-query issue, but it has a ton of gotchas, like not fully parameterizing any partially parameterized queries, or the select list of select statements. I still hit a lot of clients with those problems in their queries, making monitoring tools, Query Store, and the plan cache way less useful, and I’d love to see forced parameterization updated to fix these additional issues. If you search the the SQL feedback site for forced parameterization, there are a few dozen issues that reference it in various ways, including plan guide challenges.

Forced Parameterization v3, Handling IN Lists: When you use Contains() in a LINQ query, it gets translated into a T-SQL IN clause. This list can have different numbers of values depending on how many things you’re looking for – maybe you’re looking for just 1 value, or 10, or 100. Unfortunately, even when forced parameterization catches these, it still builds different plans for different quantities of values – like 1 value, 10 values, and 100 values all produce different plans in the cache – again, making monitoring tools, Query Store, and the plan cache way less useful. I would love the ability to just build one plan for an IN list, regardless of the number of values.

Better Approach to Query Hash: The whole reason I’m focusing on Forced Parameterization here is that SQL Server compiles different execution plans for each submitted query string. Even differences in spacing and casing cause different plans to be cached in memory – again, as discussed in this multiple-plans-one-query post. What if the optimizer was just smarter about recognizing that these two queries are really the same thing, and only caching one plan instead of building two separate plans?

SELECT * FROM StackOverflow.dbo.Users WHERE DisplayName = 'Brent Ozar';
GO
SELECT * FROM StackOverflow.dbo.Users WHERE DisplayName = 'Lady Gaga';
GO

SELECT * FROM StackOverflow.dbo.Users WHERE DisplayName = 'Brent Ozar';

SELECT * FROM StackOverflow.dbo.Users WHERE DisplayName = 'Lady Gaga';

Cost Threshold for Recompile: If a query plan’s cost is higher than X, recompile it every time rather than caching the plan. If the query cost is 5000 Query Bucks, it’s worth the extra 1-10 seconds to compile the dang thing again before we run a giant data warehouse report with the wrong parameter plan. It’s basically like adding a Query Store hint for OPTION (RECOMPILE), but doing it automatically on expensive queries rather than trying to play whack-a-mole. Here’s my feedback request for it.

We do Christmas decorations a little differently around here

Execution Threshold for Recompile: If a query has run 100 times, asynchronously compile a new plan for it, but this time around, take a lot more time to build the plan. Don’t do an early termination of statement optimization to save a few milliseconds – we’re serious about running this query. Use the execution metrics that have piled up over those 100 executions to think about whether this is really small data or big data. This is challenging to do, I know, because it means SQL Server would need a task list (like plans to be recompiled), plus an asynchronous way of processing those tasks, plus a way to know when it’s safe to run those tasks without impacting end user activity. It would also require a lot of new monitoring to know if we’re falling behind on that task list, and ways to identify which plans were re-thought, and persistence of those “better” plans in places like Query Store. Here’s my feedback request for it.

Configurable Statistics Size: SQL Server’s stats histogram size has been frozen at a max of 201 buckets since the dawn of time. In the age of big data, that’s nowhere near enough for accurate estimates, as explained in this Query Exercise challenge post and the subsequent answer and discussion posts. I wish SQL Server would switch to a larger statistics object by default, perhaps jumping to an extent per stat for large objects rather than a single page, or a configurable stats object size. This would be painful to develop, for sure – not only would it affect building the stats, but it would also impact everything that reads those stats, like PSPO which needs to detect stats outliers. Here’s the feedback request for it.

Update Statistics Faster: In SQL Server 2016, Microsoft added parallelism during stats updates, and then promptly ripped it back out in 2017, as the documentation explains in a note in the sampling section. Forget parallelism on a single stat: I want SQL Server to do a single parallel pass on a table, updating all of the statistics on that table at the same time, instead of doing separate passes of the table for each and every statistic on it. Think merry-go-round scans meets stats updates. Here’s the feedback request for it.

DDL Change Logging: When any object is modified – table, index, stored proc, database setting, server-level setting, login – have an API hook or call of some kind. Send notifications to an API to log that action: who did it, what object was changed, and what the change was. This would make true source control integration and alerting easier, not just for the database, but for the server itself, getting us closer to the point of being able to rebuild existing servers from some kind of source of truth. Yes, I know the “right” thing to do is make people check their own changes into some kind of source control system first, and then use that source control to build the server and the database, but in reality, that poses both organizational AND technical problems that most organizations can’t fix. We need a change logging system so we can at least be reactive. There have been multiple feedback requests for this over time and they’ve all gotten archived, but ever the optimist, here’s my new feedback request for it.

That last one isn’t technically a performance feature, but… if people can make changes in a production system without easy alerting, logging, and source control, then it’s a performance issue in one way or another, because people gonna break stuff. Users gonna use.

SSMS v22.4.1: Copilot is GA. So What’s It Do Right Now?

Last Updated March 21, 2026

Brent Ozar

AI, SQL Server Management Studio

Copilot in SSMS has two parts. Usually people focus on the pop-out Copilot chat window, and that’s useful for sure, but honestly I think you’re going to get way more mileage out of the code completions feature, right away, because it blends in with your existing workflows.

Let’s say that I’m working with the Stack Overflow database and I wanna find the top 10 users with the highest reputations, and for each one, find their top-scoring Post. I would start by typing a comment describing what I’m doing, then type SELECT, and the magic happens:

Copilot’s code completions automatically fill out pretty much what I’m looking for! That’s awesome. Note that I did have to type the word SELECT, but, uh, I’m okay with that. Copilot code completions don’t kick in until you at least give it a character. Hey, I’ve got plenty of characters around here. Let’s hit Tab to accept its work, and then hit enter:

We’re at an impasse until I type the word FROM, which is fine, let’s do that:

And it figures out that I want the Users table first. It even suggests aliasing the table correctly so that it matches up with what it’s already got in the SELECT! Lovely. Note that it only wrote one line – just the Users table – and not the subsequent join. Hit Tab to accept it, then enter:

Again, nothing happens until I type something else in, so we’ll prompt it with an inner join:

It adds the bang-on correct join to the Posts table, even though there’s no foreign key to explain the join, AND it lays out the WHERE clause. Note that earlier it only added one line for the From – just the Users table – but here it adds both the Posts table, and suggests no more joins are necessary, and it’s time for the WHERE clause, and adds it.

It does filter for only questions, which is something I didn’t ask for. Hmm. I would imagine that this filter and the joins are influenced by the fact that the Stack Overflow database is open source, and there’s a lot of ~~copyrighted blog posts~~ AI training material out there that Copilot learned from, so it’s automatically adding that. Your own surely private database might not get that quality of recommendations (although here of course the quality is what we call “bad”, since I didn’t ask for that filter, but “bad” is still a quality.)

Hit tab to accept, and it just sits there until we start the ORDER, at which point it fires back up with more advice:

The order is pretty good, but overall the query doesn’t produce the results we’re actually looking for, as we’ll see when we hit F5:

That’s … not what we wanted. We specifically asked for the top 10 users, and for each one, get their highest-scoring post. That’s not what we’re seeing here.

Let’s switch over to the Copilot Chat window and ask the same question:

Note that I didn’t even ask Copilot Chat to evaluate the query in the SSMS window! It just decided to do that, and gauged the code completion chat as lacking in brains. That’s fantastic! In fairness, Copilot Chat takes a hell of a lot more time to figure that out, and as its analysis continues…

It shows the results, and those results are bang on. I love how it adds the top post title, too, which our code completions query didn’t. Continue scrolling down and after the results:

Brilliant! It … well, it doesn’t show me the actual query it wrote, but it does follow exactly what I asked for. I technically didn’t ask it to write the query – I just asked it for the results, so I’m left with copy/pasting the results out of the text, or asking it to show me its query.

If you want to get a feel for the real time response speed, you can watch this going down in the silent video below:

(No audio narration from me on that one because I was jamming out to the John Summit set in Vail as I wrote this post, getting psyched up for Experts Only Vail this weekend. Any EDM fans in the house?)

My verdict: enable code completions, NOW.

I adore Copilot’s code completions because they show up where you are. You have to enable them by going into Tools, Options, Text Editor, Inline Suggestions, and Copilot completions, then go into Inline Suggestions, Preferences, and check Show suggestions only after a pause in typing. (Otherwise they’re obnoxiously fast and when you hit tab, you’ll get the wrong stuff constantly, and you’ll be constantly forced to go back.)

Are they as good as a human can do? Not even close, as this quick & dirty demo showed. Code completions just makes your life easier, silently, as you’re working, without interrupting the tools and workflow you’re already used to using. I feel like it’s about 70% accurate, 30% inaccurate, which sounds terrible, but that 70% is massively helpful.

The Copilot Chat window is much more accurate, but it’s slow as hell in comparison, and it requires you to change your workflow. Nothing against that – it does good work – but I know you, dear reader, and you’re lazy. You’re not gonna switch over to the chat window. You’re gonna just keep typing in SSMS, and for that, Copilot code completions is the bomb.

Now if you’ll forgive me, I wanna go throw a sweater in the car for the road trip lest I shiver.

Get Free SQL Stuff

"*" indicates required fields

Facebook

This field is for validation purposes and should be left unchanged.

Name*

First Last

Email*

Things I want*

First Responder Kit (Scripts and Guides)

Monday Links (SQL & tech news)

Blog posts (2-4 per week)

Blog

How big are the servers out there?

sp_Blitz Changes

sp_BlitzCache Changes

sp_BlitzIndex Changes

sp_BlitzLock Changes

sp_BlitzWho Changes

sp_kill Changes

Consultant Toolkit Changes

For Support

The density vectors aren’t very useful.

But what about the histogram?

Things change a little for really big outliers.

Multi-column stats just don’t help much by themselves.

Option 1: ask Copilot to write the query for you.

Option 2: use this user-defined function.

Dev-Prod Demon Hunters: Finding the Real Cause of Production Slowness

3 things you’ll get out of this session

My verdict: enable code completions, NOW.

Hi! I’m Brent Ozar.

Get Free SQL Stuff

Dev-Prod Demon Hunters:
Finding the Real Cause of Production Slowness