Visual Studio works best when you can see what’s happening and trust the tools you’ve added to your workflow. The June update is built around both. The Copilot Usage window gets a refresh with proactive alerts as you approach your limits, MCP servers now get a trust check before they run anything new, and the GitHub Copilot modernization agent for C++ graduates to general availability for MSVC upgrades.

We’ve also extended next edit suggestions across the entire active file and brought full-color emojis everywhere the editor renders text. Install the June Stable Channel update when you’re ready, then take a look at what’s new below.

Copilot usage tracking and alerts

GitHub Copilot usage is now calculated based on token consumption rather than by request, as part of its usage-based billing model. The refreshed Copilot Usage window in Visual Studio gives you a clearer view of where you stand against that model, with real-time updates as you work. Open it any time from the Copilot badge menu > Copilot Usage.

You’ll also see proactive alerts as you approach a limit, when you hit it, and when additional usage (overages) activates. The quota warning threshold is configurable, so you can decide how early you want the heads-up.

This is the start of a broader investment in Copilot usage visibility. Expect more in upcoming releases, and let us know on Developer Community what would help most.

Trust validation for MCP servers

MCP servers extend Copilot’s reach, and as more of your day-to-day workflow runs through them, the question of whether they’ve quietly changed underneath you becomes worth asking. Visual Studio now validates MCP server trust in two places during startup. Before the server process starts, the current configuration is compared against a previously trusted baseline. After it starts, the fingerprint of its tools, prompts, resources, and instructions is compared to the last-trusted fingerprint. If anything has diverged, a trust dialog asks you to review the changes before the server is allowed to run.

From the dialog you can accept the changes (which updates the baseline), check Don’t show me this dialog again for this server and pick Trust to always trust the server going forward, or pick Do not trust to reject the changes and abort startup. First-time connections are implicitly trusted and seed the initial baseline. Built-in servers, servers under a RegistryOnly policy, and any server you’ve explicitly set to always-trust skip the prompt entirely.

Trust validation is on by default. You can manage it at Tools > Options > GitHub > Copilot > Copilot Chat > Show trust dialog before running tools from an updated MCP server.

GitHub Copilot modernization agent for C++

The first C++ scenarios for the GitHub Copilot modernization agent are now generally available. These are the flows that upgrade your C++ projects to the latest version of the Microsoft C++ (MSVC) Build Tools, where the new features, performance improvements, and security updates live.

The agent analyzes your project, identifies compatibility issues, and lays out an upgrade plan. Run it in Automated mode to let it carry out the upgrade end to end, or in Guided mode to review and approve the assessment, plan, and execution steps before each one runs. Right-click a solution or project in Solution Explorer and pick Modernize, or open Copilot Chat and type @Modernize followed by your upgrade request.

Thanks to the developers who put the preview through its paces on real C++ projects — your feedback shaped where this landed. Let us know which C++ modernization scenarios you want next on the C++ Developer Community.

Long-distance next edit suggestions

Make a change in one place, and you usually know there are related edits to make further down the same file. GitHub Copilot’s next edit suggestions (NES) have always anticipated the next change, but until now they were limited to the area immediately around your cursor. That’s often not where the related edits actually are.

Long-distance next edit suggestions extends NES across the full active file. Copilot can predict and propose edits anywhere in the current file, helping you keep related code in sync without manually hopping between sections.

The feature is off by default for now. Turn it on under Tools > Options > Text Editor > Inline Suggestions by checking Enable extended range suggestions. The deep dive on the model training and evaluation behind long-distance NES is worth a read if you want the back story. Give it a try and tell us how it lands.

Color emojis

Emojis are now rendered in full color across Visual Studio. The same emoji you use to flag a bug, mark a section header, or highlight a TODO shows up with its real colors in the editor, in markdown previews, in GitHub Copilot Chat, in build output, and in Solution Explorer.

A red stands out as a warning, and a green reads as confirmation. The rendering uses modern font technologies, so what you see matches what your teammates see regardless of which Windows version they’re on.

---

From our entire team, thank you for choosing Visual Studio! For the latest updates, resources, and news, check out the Visual Studio Hub and stay in touch.

Happy coding! The Visual Studio team

The post Visual Studio June Update – Track Your Usage, Trust Your Tools appeared first on Visual Studio Blog.

Oh boy, more random stuff.

• The hardest working font in Manhattan: Marcin Wichary digs up the history of the font named Gorton. I grew up with this font, seeing it not only on punch card keyboards but also in a Leroy lettering kit that we used in sixth grade graphics class when we studied mechanical drawing.
• RollerCoaster Tycoon’s Overengineered Puking System. Learn more than you ever needed to know about the algorithms in the game RollerCoaster Tycoon that determine when a park guest pukes. No really.
• The Spaghetti Policy for All MLB Teams by the appropriately named Sickos Committee breaks down the outside food policies for all of teams in Major League Baseball to determine which ones would let you bring in a gallon of spaghetti. The first part is fairly straightforward, but it gets far more weird (and sicko) as they look at the stadiums where a gallon of spaghetti might not be permitted. (Background information: Sports fans in Philadelphia have a reputation for poor behavior. These are the people who booed Santa Claus and pelted him with snowballs.)
• We have reached the second generation now. “Microsoft invented “escrow builds” to launch functional apps – that’s internal ‘Microspeak’ jargon for quality control” is a rehash of my article on the history of the term “escrow”, but the article appears to just be a suspicious mishmash of fragments from the article. For example, in the sentence “He described it as unhelpful because the blog essentially described a metaphor using another metaphor” the antecedents of “it” and “the blog” are not present in the article, leading the reader to think that “it” is the explanation of what escrow means and that “the blog” is my blog. On top of that, the title of the article introduces the phrase “launch functional apps” (whatever that means), even though none of those three words appear anywhere in the original article, nor in the dodgy rehash. Undaunted, a different AI content farm picked up on that article and somehow expanded it into an even longer article that conveys even less information.

The post 2026 mid-year link clearance appeared first on The Old New Thing.

Using NativeAOT to write a .NET GC in C#. In this part, we add support for finalization.

---

Have you ever wondered how much the model you pick in Copilot Cowork actually changes the result — and the bill? I ran a proper little experiment.

Today is July 1, 2026 — the day you need Copilot Credits available to keep using Cowork. Which makes this the perfect moment to ask the question everyone keeps asking me: which model should I pick, and what does it cost me? In my post on the UI refresh and the /cost skill(opens in new window) I showed you how to see what a task costs. This post is the natural follow-up: same prompt, different brains, measured side by side.

And the nice thing is this becomes a reference I can re-run every time a new model shows up in the picker. Let’s take a closer look.

1. The experiment – one prompt, every model
2. The results – same prompt, different outcomes
   1. Claude Sonnet 5 – the efficiency champion
   2. Claude Opus 4.8 – a good looking deck
   3. GPT-5.5 – the expensive lesson
   4. Auto – the smart middle path
   5. The scoreboard
   6. Stepping outside Cowork – the app comparison
      1. Copilot Chat – Design a presentation
      2. Copilot in PowerPoint – the surprise
3. Conclusion – what I would actually do
4. Closing thoughts

The experiment – one prompt, every model

The idea is simple. I take one prompt, run it through each model in Cowork, and then judge two things: how good is the result, and how many Copilot Credits did it burn (via /cost). Nothing fancy about the task — a training introduction deck for Cowork, the kind of thing a lot of you are building right now anyway.

The models in the ring: Claude Sonnet 5, Claude Opus 4.8, GPT-5.5, and Auto (which lets Cowork pick the best model for the job). Then, for good measure, I compared against Copilot Chat and Copilot in PowerPoint — because those don’t touch your credits at all.

One important note before the results: I deliberately did not say anything about how the slides should look. No template, no color guidance, no “make it match our brand”. Just the content structure. That is on purpose — I want to see what each model does when left to its own taste. Here is the exact prompt I used, the same one every single time:

Create a visual 6-slide presentation for a training introducing Microsoft Copilot Cowork to large enterprise company knowledge workers, who have used Microsoft 365 Copilot. Discover information from Microsoft Learn and Microsoft Support 

Include these slides in the presentation
1. Title slide — "Introducing Cowork"
2. What is Cowork (plain-language definition)
3. Key capabilities across email, calendar, meetings and documents
4. Copilot Chat versus Copilot Agents versus Copilot Cowork
5. Skills and automation — what you can build
6. How to get started

Keep the wording concise​

The results – same prompt, different outcomes

Let me take them one at a time, because the spread here genuinely surprised me.

Claude Sonnet 5 – the efficiency champion

Sonnet used 1 Copilot Credit. One!

Now, I am not going to pretend I fully trust that number — the amount is so small that I am honestly not sure it is being calculated correctly. But even if the real figure is higher, the point stands.

The resulting PowerPoint is quite nice looking. Simple, but it looks good enough. For the price, this is a winner, no question.

Claude Opus 4.8 – a good looking deck

Opus used 325.8 Copilot Credits — about $3.26 on PayGo at $0.01 per credit.

The presentation looks good. It is clearly better than the one Sonnet made — the content is more thoughtful and it is more visual. This is the frontier model doing frontier-model things. You pay more, you get more polish. This doesn’t mean every slide looks better automatically – for example from these results I like Sonnet’s Copilot Chat vs Agents vs Cowork comparison more.

GPT-5.5 – the expensive lesson

This one took a very long time to create the presentation. And it used the most credits of the whole test: 1291.4 — roughly $12.91.

Here is the honest part: the resulting PowerPoint didn’t even open until the PowerPoint app repaired it a few times. And once it did open, the result was the weakest of all the options.

So my takeaway is not “GPT-5.5 is bad” — it is more specific than that: based on this test, don’t reach for GPT-5.5 to build presentations. Use it for other kinds of work where it shines.

Auto – the smart middle path

Auto used 227.9 Copilot Credits — about $2.28.

And the result is really good. Visual and thoughtful. My hunch is that the slide deck itself was generated with Opus, while some of the research was handled by a lighter model to keep the price down — which is exactly what you want Auto to be doing. It came in cheaper than pure Opus (227.9 vs 325.8 credits) while landing very close on quality. I would pick this result out of these three.

The scoreboard

Here is the whole thing in one view (cost at $0.01/credit on PayGo):

Model	Copilot Credits	~Cost	Verdict
Claude Sonnet 5	1	~$0.01	Best value — simple but good enough
Claude Opus 4.8	325.8	~$3.26	Very good visuals and content
GPT-5.5	1291.4	~$12.91	Slowest, priciest, weakest deck
Auto	227.9	~$2.28	Very good visuals and quality, lower cost than Opus

Stepping outside Cowork – the app comparison

Cowork isn’t the only place Copilot can build a deck for you. So I ran the same brief through two other routes that don’t spend any credits, because their usage is included in your Copilot license.

Copilot Chat – Design a presentation

I asked Copilot Chat (on Auto) to build the deck using the Design a presentation capability.

The result isn’t good — there is clearly some effort on visuals — but it is not the one for training use. It would need a lot of manual work to get there. My tip: with Copilot Chat, it makes sense to do a planning session first, where you draft the outline in a conversation, and then feed that result into Design a presentation to generate the slides. Two steps, much better outcome.

Just a couple of slides of this run outcome:

Copilot in PowerPoint – the surprise

Then I asked Copilot in PowerPoint (on Auto) to create the same presentation. And this is where it gets good.

PowerPoint started by asking me questions about the presentation before it built anything. This generation took the longest of everything I tried — but the result is very visual, it also generates images, and the content is good too. Sonnet and Opus produced more readable slides, but that is a gap you could close in PowerPoint with a better prompt or a template. Or just fine-tune some colors of elements to increase contrast and accessibility to read it.

I have to say I was genuinely surprised by the quality here ( perhaps I should have used this more during past couple of months). The catch is the interaction model: there will be questions you have to answer, so you can’t just fire the prompt and walk away. In fact you must keep PowerPoint open the whole time it generates — unlike Cowork, where you hand over the task and can close the browser entirely. Cowork keeps working in the cloud. That difference matters more than it sounds.

Conclusion – what I would actually do

A few clear takeaways from this one:

• For credits-per-quality, Claude Sonnet 5 is the winner — assuming /cost is showing me the true number. Even if that “1 credit” is really 50, it is still a clear winner. Auto and Opus 4.8 gives you the better looking deck, but that visuality comes with some cost. And GPT-5.5 — based on this test — is one to keep away from presentations and point at other work instead.
• Copilot in PowerPoint is a winner too, and honestly the surprise of the day. It costs no credits (it is included in your Copilot license) and it clearly uses Claude models in the background, based on the result. The downside is you have to answer its questions and keep the app open while it works.
• We are using generative AI here – results will be always different. Sometimes Opus can provide text alignment or other errors, and sometimes content model chooses just doesn’t work for the result. The better the prompt, more consistent results you can get – and thus better outcomes.

So if I am creating a single, simple PowerPoint and I have the time to sit with it, I would use Copilot in PowerPoint — no credits, great visuals. Otherwise I would use Cowork with Sonnet to see if I get the result that is good enough. Depending on complexity of the source materials, I might create a PowerPoint with Cowork using Auto, but not before I have tested out that the result is what I need with Sonnet.

But here is the bigger picture. This test is just one type of task. The moment you need several outcomes from a single prompt — a deck and a Word doc and an Excel summary and a few emails — going app by app means a lot of time hopping between Microsoft 365 apps and answering questions in each one. That is exactly the job Cowork was built for: one prompt, walk away, come back to finished work.

For that kind of multi-output work in Cowork, lean on Sonnet to save credits while still getting quite good results — and reach for Auto or Opus when the polish genuinely matters.

New models will keep landing in the Cowork picker (Sonnet 5 wasn’t even there yesterday). So instead of re-judging every new model from scratch, keep 2–3 standard test tasks ( prompts and sources) in your back pocket and re-run them each time. Same input, new brain — the differences jump right out. Run those, jot down the /cost number and a one-line quality note each time, and you have a living benchmark instead of a gut feeling. Note to myself: keep this exact post as the template for the next model.

Closing thoughts

What I like most about this little experiment is that model choice in Cowork is a real lever — for quality and for cost — and now, with /cost, it is a lever you can actually measure. The winner today might not be the winner next month, and that is the fun of it.

Have you run the same prompt across different models yet? I would love to hear which one came out on top for your kind of work — drop a comment. And go run /cost on the tasks you actually do this week. It is the most useful five minutes you’ll spend in Cowork right now.

Thanks for reading — and here’s to letting the machines do the heavy lifting while we go grab that coffee or tea.

PS. Using Auto selection, Cowork used just 76 credits to write the first draft of this text. The more information you provide the better result you get faster.

We recently released a major upgrade to our secure boot provisioning software, rpi-sb-provisioner, making it easier to provision more complex operating system images and deploy Raspberry Pi Connect at scale.

In my many years as a software engineer, I always found working with secure boot more complicated than it had any right to be. So, in 2024, we released the first version of rpi-sb-provisioner: a system designed to help you provision your OS on devices with secure boot and full disk encryption enabled in a boring and predictable way.

Since then, we’ve received plenty of feedback from users, and the provisioner has evolved significantly — from a collection of shell scripts and tools to a system with a manufacturing database, an audit log, and a web UI. Every change was designed to address a concrete user problem.

Of course, there’s more to making Raspberry Pi–powered devices and projects than simply getting your OS onto the system; we also had to teach rpi-sb-provisioner to play nicely with our other tools.

Integrating Raspberry Pi Connect

Users continue to tell us how useful they find Raspberry Pi Connect for remotely managing their devices. But when you’re provisioning devices at scale, you can’t afford to slow down to manually associate each one; you also want those associations to survive OS updates, factory resets, and so on.

Version 2.3 of rpi-sb-provisioner makes use of the new device identity support in Raspberry Pi Connect for Organisations, allowing you to automatically give your devices an immutable identity and tie them to your Raspberry Pi Connect for Organisations account.

Flexible image description provisioning

Previous releases of rpi-sb-provisioner assumed that you had created a traditional Raspberry Pi OS–derived image using pi-gen. After the initial release, however, we received a range of questions from users who wanted to provision more complex layouts or build images in a more ergonomic way. To address both needs, we introduced image description provisioning (IDP) in rpi-image-gen, which is now integrated into version 2.3 of rpi-sb-provisioner.

Image description provisioning transforms rpi-sb-provisioner from a fixed-function provisioner into a fully programmable provisioning system, enabling you to specify a wide range of partition layouts, types, and other attributes. IDP can also be used to provision operating systems that weren’t created with rpi-image-gen: if you can describe it, you can provision it.

Making use of rpi-fw-crypto

With the release of rpi-fw-crypto, Raspberry Pi devices now have a mechanism for using asymmetric cryptography without unduly exposing the device-unique private key written by rpi-sb-provisioner. We make use of this function in two major areas:

1. On the provisioning server, to encrypt and bind the signing material (a PEM file or HSM PIN) to the provisioning server.
2. On the provisioned devices, as part of the material used to calculate a full disk encryption key, either through a supplied pre-boot authentication environment or one you build with rpi-image-gen.

More to come

The rpi-sb-provisioner system will continue to evolve to respond to user needs. Sharing feedback on the tool and how it has or hasn’t worked for you, or just hard-earned tales from manufacturing devices at scale, helps us make the system better for our customers — industrial, embedded, and enthusiast alike.

Find out more about provisioning Raspberry Pi Connect at scale in our bulk provisioning documentation.

rpi-sb-provisioner, rpi-fw-crypto, and rpi-image-gen are all open source projects available on our software sources page.

The post Secure Raspberry Pi Connect at scale appeared first on Raspberry Pi.

Learn T-SQL With Erik: Aligning Queries and Indexes Part 1

---

Chapters

• 00:00:00 – Introduction
• 00:01:01 – Helpful Links and Services
• 00:02:01 – Free SQL Server Performance Tool
• 00:03:43 – Current Indexes Overview
• 00:05:04 – Query Analysis and Challenges
• 00:06:12 – Index Seek Improvements
• 00:07:22 – Cross Apply for Better Performance
• 00:08:13 – Execution Plan Breakdown
• 00:10:04 – Final Optimization Steps

Full Transcript

Erik Darling here with Darling Data and today’s video we are going to continue our learning T-SQL journey here and we are going to spend we’re gonna spend a few videos talking about how you can align your queries and your indexes for better performance some videos will change indexes some videos will change queries but at the end of the day we will have a fucking good time I think and we’ll all learn a lot and I’ll convince all of you to buy the full Learn T-SQL with Erik course that’s the plan anyway right I’m just gonna fight you off in droves all the all the sales we’re gonna make here down in the video description is where you can find a link to purchase the very course that this this material is a very small portion of a very tiny little itty-bitty part of the world you can also find other really helpful links in there to help you achieve all of your goals and dreams in life you can hire me for consulting you can buy this training and other training too I’ve got other stuff if you don’t like you know you don’t like these more whatever you can also become a supporting member of the channel if you would if you would feel that generous and you would like to share four dollars a month with me you can ask me office hours questions that is absolutely free every Tuesday I answer five of them from whoever sends him in and of course I do appreciate this channel’s stunning massive unprecedented growth someday I’m gonna have twice as many members as that amiga repair channel I think but if you would be so kind as to Like subscribe and of course tell a friend about the wonders and glories that take place here on the darling data channel that would be cool too I’m If you’re in the market for something free, and that free something happens to be a SQL Server performance monitoring tool, I’ve got one. Isn’t that crazy?

Totally free, totally open source, no email to sign up, no phoning home with any weird data about what it’s doing, what’s going on in your servers. It’s just a bunch of T-SQL collectors that run, grab the right stuff, all this important stuff for monitoring SQL Server, all this stuff that I care about and dig deeply into when I’m doing a performance analysis on a SQL Server.

And it’s got built-in MCP tooling as well. So if you choose to enable the MCP servers and the MCP tooling, you can have your robot companion friends look at your monitoring data, and just your monitoring data, in order to see how things, how things look, and give you some analysis of what has been collected.

Coming up in the very near future, I will be at Data Saturday Croatia, June 12th and 13th. And then, unless something magnificent happens, I will be home making these videos for the masses until November 9th through 11th, when I will be at PASS Data Community Summit in Seattle, Washington.

But with that out of the way, let us continue our romp through the month, the month of May here, and let’s talk about how we can change queries to better fit the indexes that we have in place.

And how that will, of course, make them go faster. Ah, crazy! Look at that. You can do all sorts of fun stuff. So these are the two indexes that we currently have.

This index is less important. The index that we are going to focus on aligning our query better with is this index right here. It’s on the left side.

on the post table and it is keyed on owner user ID, post type ID, and then the score column in descending order. So we can pretend that these indexes exist for any of the number, any variety of reasons that indexes often exist in databases.

Perhaps they were there for some other query and a new query that we wrote just happened to be picking up on them. So what we’re gonna do first is run this query. And the part of this query that we wanna focus on is kind of what’s going on here first.

So this is a derived join. And one of the limitations of derived joins is that they can’t, they are not aware of anything going on outside of them.

Just as an example, if I tried to tell this thing anything about the users table, like if I tried to say p.ownerUserId equals u.id, SQL Server rather, we would get this little squiggle over here and this thing would say, I have no idea where this ID column is.

I don’t know what you’re talking about. Stranger danger. That thing doesn’t exist. We have to wait until we get out here for that to get picked up. So what happens quite often when we do this is that, well, SQL Server, like, you know, even though we have this wonderful index leaning on ownerUserId, SQL Server does not find a way to seek into the ownerUserId column when the query is written like this.

And so we end up with a query. And this is the compatibility level hint here. In the full training, of course, there are some comparisons that are not, did not make the cut for this video, but that’s what that’s there for.

But also to just make sure that we get something relatively batch modey. And because this query executes in batch mode, it did not run for one millisecond. That is just how long the sort ran for.

If we come all the way over here, we will see that we spent three seconds scanning the post table with a single thread, right? There’s no parallelism going on in this plan, right? 3.051 seconds.

I can move that over a little bit so that my big head isn’t in the way so much. So obviously, you know, this is a query. We want it to go faster. How are we gonna make it go faster?

What are our chances? What are our options here? Well, one way to make this query go faster might be to change from using a derived join to using a cross supply.

Since we are, since the original query was written using an inner join, this will be using cross supply. Cross supply is like an inner join. Outer apply is more like an outer join, left outer join for being very specific.

But because cross supply is sort of like a wonderful mix of a for each loop and kind of like a sub query, inside the cross supply, we can actually reference that ID column from outside, right?

And when we do that, SQL Server is able to make better use of the index that we have. So I didn’t run this yet.

I just want to come back to this. So here notice like this, we are scanning this index, right? When we hit this index, the predicates that we’re applying are on post type ID. And over here we are filtering out to where, well, we have the row number function filtering out to where row number equals one.

But we also have a bitmap that got pushed down a little bit. Not all the way down here because it’s a mixed, you know, it’s batch mode on rowstore. so we can’t do all the nice stuff that we do with normal bitmaps.

But here we have a bitmap that’s also filtering out owner user IDs. Now, coming back to our cross-apply query, one thing that’s kind of nice and one thing that kind of shows us how SQL Server treats these differently is that we don’t need to have the partition by owner user ID here because it’s implied in here on the correlation, right?

Up here, we needed to partition by owner user ID and stuff, right? Down here, we don’t need to do that, right? So if we do this, we go from three seconds to about 1.5 seconds, right?

This query does not lie to us so much at the end. So and over here, we have a seek into our index, right? So over here, we’re able to apply that seek predicate not only to owner user ID but also to the post type ID stuff.

But this does bring up something that I kind of don’t like and this happens quite a bit with nested loops plans is we are getting a sort of a double seek in here.

We have one seek keys, one up here and two seek keys, one down here. So we have two seek predicates sort of separately going into this index and doing their seeks, which I don’t love.

We’re going to talk about what ways we can address that in a moment. But another way of rewriting this query, so like before with the derived, we were essentially ginning up a row number over this entire result set.

Down here in this one, we’re essentially generating a row number over only every owner user ID that comes in, right? So we generate a row number over these.

So instead of doing one big sort, we do lots of smaller sorts. That’s a pretty good start, right? We got a parallel plan out of it. We no longer had the single threaded plan. We improved our time by two.

But this isn’t always the best way to figure out like what the… what the high score is for something. A lot of times, you’ll want to test different ways of getting the same data because under different circumstances, different techniques might produce better performance results as long as they also give you correct logical results.

That’s a nice plus, right? But here, instead of generating a row number for every user ID and then filtering on it, we’re just going to ask for the max here.

Remember, we are at about 1.5 seconds with continuing with the row number technique. And if we run this one with the max, we get down to about 667 milliseconds.

So we improved there by like another half, right? We got twice as fast using the max technique, which is fine.

But still over here, we have sort of the same kind of thing that I was talking about with the one seat keys one and the two seat keys two. So we’re still doing this like multi-seq or dynamic seek into the index, which I still don’t like very much.

So what we’re going to do is change our query a little bit and we are going to run it like this instead. And I’m just going to execute that and then come back up here and show you that we got the max score for this here and the max score for this here.

One is for post type ID equals one. Well, the other is for post type ID equals one. So we’re doing two separate hits of the post table. And now this query finishes in about 15 milliseconds, right? Because we’re no longer doing that sort of that multi-seq within one seek operator.

We have broken this out and we’ve given SQL Server two very clean predicates to seek into and figure out what we want to get out of each one. We could even do that with top one.

And top one, of course, would give us the same result here. So we run this. And this gets down to, well, it’s just about the same execution plan. It also finishes in about 15 milliseconds.

So this is just another example of how we can better align queries to the indexes that we have. Whenever you’re query tuning, whenever you’re out there looking at execution plans, if you see something in there you don’t love, like it started off, we had an index scan on an index and we knew that that index led with the column that we’re, one of the columns that we’re correlating on owner user ID.

We just knew something wasn’t right. Something was amiss with that execution plan. And by rewriting the query, we got SQL Server to take better advantage of an index that we already had kicking around.

All right. Thank you for watching. I hope you enjoyed yourselves. I hope you learned something. And I will see you in tomorrow’s video where we will talk about something, I guess, rather similar to this, because I did promise we would spend some time talking about aligning queries and indexes.

Anyway, thank you for watching.

Going Further

---

If this is the kind of SQL Server stuff you love learning about, you’ll love my training. Blog readers get 25% off the Everything Bundle — over 100 hours of performance tuning content. Need hands-on help? I offer consulting engagements from targeted investigations to ongoing retainers. Want a quick sanity check before committing to a full engagement? Schedule a call — no commitment required.

The post Learn T-SQL With Erik: Aligning Queries and Indexes Part 1 appeared first on Darling Data.