SQL Server Performance Weekly Recap – What You Might Have Missed This Week!

SQL Server Performance Weekly Recap – What You Might Have Missed This Week! 👌

Hi SQL SERVER Guys,

This week we explored some of the most important SQL Server performance topics. Some of them challenge common habits developers have used for years. Others reveal optimization techniques that can dramatically improve query performance.

If you missed some of the posts, here is a quick recap of the posts of the week:

SQL SERVER! SARGability: the One Concept You Absolutely Must Understand!

If there is one concept every SQL Server developer must understand, it is SARGability.

A non-SARGable predicate can silently destroy performance by preventing SQL Server from using indexes efficiently. In this article we explored why SARGability matters and how a small rewrite can completely change the execution plan.

The Most Dangerous SQL Server Query Pattern Nobody Talks About

There is a query pattern that appears perfectly innocent… but can cause huge performance problems.

Many developers use it without realizing that SQL Server may be forced into expensive scans or inefficient plans. This post shows why the pattern is dangerous and how to rewrite it safely.

Why Most Developers Should Stop Using XML in SQL Server!

XML can be powerful, but it can also be extremely expensive.

In this article we explored why XML queries often become slow, why XML processing is heavier than most developers expect, and when XML should simply be avoided.

JSON vs XML Indexing in SQL Server – The Ultimate Performance Showdown!

This article compares JSON and XML indexing in SQL Server with real benchmarks.

The results highlight how indexing strategies can dramatically affect performance and why JSON can sometimes be a better alternative depending on the workload.

Understanding the Engine Beyond Traditional Indexes – XML Indexes

Most developers know traditional indexes very well, but far fewer understand how XML indexes actually work.

In this deep dive we explored how SQL Server internally structures XML indexes and when they can improve performance.

I Removed 32 Seconds From This SQL Server Query… Without Adding an Index!

Not every optimization requires a new index.

Sometimes understanding the execution plan and how the engine behaves is enough to remove massive bottlenecks. In this case we reduced execution time by 32 seconds without touching the schema.

Make Your SQL Server Fly – Batch Mode Continues

Batch Mode on Rowstore is one of the most interesting performance features introduced in modern versions of SQL Server.

This article continues the series showing how the engine can dramatically speed up queries even without columnstore indexes.

No New Index. No Schema Changes. Just Pure Engine Optimization!

Sometimes the biggest improvements come from understanding how the SQL Server engine really works.

This post shows how query design and engine behavior can produce major performance improvements without modifying the database structure.

10x Faster Queries – Batch Mode on Rowstore Deep Dive

One of the most surprising features in SQL Server is the ability to execute queries up to 10x faster using Batch Mode on Rowstore.

In this deep dive we explored how the optimizer enables this mode and why it can completely change performance characteristics.

Final Thought

SQL Server performance is rarely about a single trick.

It is about understanding:

  • how the optimizer thinks
  • how execution plans work
  • when indexes help
  • when query design matters more than indexes

And sometimes the biggest improvements come from things developers rarely consider.

See you next week for more SQL Server performance insights.


Luca Biondi @2026

Comments

Post a Comment

I Post più popolari

Speaking to Sql Server, sniffing the TDS protocol

Image
Hello friends!  If yesterday you read my post and found it definitely boring (for the topic of course and not for how it was written to the author 😁) well today I promise you that the topic will be much more interesting! Let's talk about Sniffing , let's talk about going to see what happens when we "log in" or when we send a Query to SQL Server.  We will do this by taking a look to the little known tabular data stream (TDS) protocol built on top of the TCP/IP protocol. Ready! The TDS protocol What is the Tabular data stream (TDS) protocol?  The TDS is the protocol used by the SQL Server client Net-Library to communicates with SQL Server . TDS is specific to SQL Server and it is a low-level protocol that specifies both commands and data in a specific arrangement.  TDS encapsulate the TCP/IP protocol. Sniffing TDS packets you can read from the network the requests that your application do to the SQL Server and read the answer .   How to Sniff data from the ne...
Read more

SQL Server, find text in a Trigger, Stored Procedures, View and Function. Two ways and what ways is better

Image
Hi guys, Welcome back! Today a light post about a question that has been asked to me several times. The question is: how to  search for text inside a trigger or a stored procedure ? We have two different ways. A first way using a system view called syscomments: SELECT obj.xtype, text , * FROM sysobjects obj JOIN syscomments com on obj.id = com.id WHERE TEXT like '%text_that_i_am_searching_for%' A second way using a system view called sql_module: SELECT o. name AS Object_Name, o. type_desc , m. definition FROM sys.sql_modules m JOIN sys.objects o ON m. object_id = o. object_id WHERE m. definition Like '%text_that_i_am_searching_for%' ;   Another question is? What differences do we have in using one way instead of the other? Which solution is better? You have to consider that the system view sys.syscomment is obsolete and will be removed sooner or later. So don't use it in production enviroiments. The sys.sql_m...
Read more

SQL Server, Avoid that damn Table Spool!

Image
Hi guys, Welcome back for another post! A light one inspired from what i do during my work: many times I optimize queries rewriting them or adding index and i like it very much! Sometimes you need to use a little imagination, but everything you learn ... sooner or later it will come in handy! Enjoy the reading mates! Avoid the Table Spool, when you can A few days ago I came across a query whose execution time was very high ... or so it was for the client complaining about the problem. Before recreating it, let's create the structures and fill the tables with some data Create table PriceList (Id int identity (1,1) primary Key ,Code Varchar (20)) Insert into PriceList (code) select top 1000 right( '0000' + cast ( row_number () over ( order by id) as varchar (4)),4) from artico Insert into PriceList (code) select top 4000 right( '1000' + cast ( row_number () over ( order by id) as varchar (4)),4) from artico Create table OrdersList (Id int identity...
Read more