SQL Server Database Optimization – a Beginner’s Guide
by John Pasquet
Over the past month, I’ve been analyzing our SQL Server Database activity to identify and resolve any significantly inefficient queries. Through the process I’ve learned a few things that may help other people who are doing the same work. Let me know what you think.
- Focus on Reads and CPU.
If a query has a high number of reads, then it is likely that either a table is not indexed properly or a query is written in such a way that appropriate indexes cannot be used. If the CPU is particularly high, a variety of factors could be at issue.
- Identify BOTH expensive individual queries AND expensive aggregate queries.
When I started, I just focused on identifying the queries with the highest read counts and CPU. That’s certainly helpful if very expensive queries can be significantly optimized. However, an expensive query that is rarely runs is probably not as problematic as a moderately expensive query that runs very often.
For instance, one query may run about once an hour and have 100,000 reads and 500 CPU. Yet, another query may only have 25,000 reads and 125 CPU, but runs 100 times an hour. The cumulative hourly expense would therefore be 2,500,000 reads and 12,500 CPU—a much higher expense than the query that only runs once an hour.
- Create a Baseline for your database
As you achieve performance improvements, you will want to compare them with how the system performed prior to the improvements being made. Having a baseline will allow you to quantify the improvements made in real numbers. Seeing significant improvements is very satisfying and well worth the time.
- Create a baseline copy of the database – This will allow you to compare how new indexes impact performance.
- Store a run of SQL Profiler as a baseline – Profiler allows you to write results to a database table. Name it “Baseline” or something like that. I write to a test database to isolate that work from development. It may be good to do two runs—one that perhaps catches all queries with more than 1,000 reads and one for all queries with more than 100 CPU for a time period of 30 minutes. (These numbers certainly depend on the size and structure of your particular database. You may want to do some preliminary runs to figure out the best numbers for your database.)
- From SQL Server Management Studio => Tools => SQL Server Profiler
- Select database
- Click “Save to Table” on General tab. Select development database. Table name = “Baseline”. (or Baseline_Reads_5000 and Baseline_CPU_100)
- Events Selection Tab: TSQL – SQL BatchCompleted and Stored Procedures – RPC:Completed (if you use stored procedures)
- Column Filters:
- Run 1: Reads – Greater than or Equal – 5000 //Exclude rows that do not contain values
- Run 2: CPU – Greater than or Equal – 100 //Exclude rows that do not contain values
- Identify Expensive Queries
Query your baseline run of SQL Profiler. The following query could be of great help. It aggregates the total reads and total CPU, allowing you to sort by those columns. This allows you to see which queries are the most expensive from an aggregate perspective. Some queries that are rarely run still may show up in such sorts. This really emphasizes the importance of tackling such queries.
The key grouping is on “SUBSTRING(Textdata, 1, 150)”. Each query that is run typically has variables appended to the end of the query. Comparing the first part of the query can allow identical queries with different parameters to be grouped together to provide aggregate results. You may need to play with the number of characters from time to time.
I also group by DatabaseName, since multiple databases may be stored on the same server.
SELECT DatabaseName, COUNT(*) AS [Query Count], SUM(CPU) AS [CPU Query Total], AVG(CPU) AS [CPU Per Query], SUM(Reads) AS [Reads Query Total], AVG(Reads) AS [Reads Per Query], SUBSTRING(Textdata, 1, 150) AS Query FROM My_Database GROUP BY DatabaseName, SUBSTRING(Textdata, 1, 150) ORDER BY [Reads, Query, Total] DESC
This is another query that is a little more complex, but it adds some interesting information. Specifically, it gets the totals across all queries (that met the read or CPU threshold) for query counts, Reads, and CPU, then computes the percentages for each query.
WITH [Total All Queries] AS ( SELECT COUNT(*) AS [Query Count], SUM(CPU) AS [Total CPU], SUM(Reads) AS [Total Reads] FROM My_Database )</p> SELECT DatabaseName, COUNT(*) AS [Query Count], CAST(COUNT(*) * 100.0 / (SELECT TOP 1 [Query Count] FROM [Total All Queries]) AS DECIMAL(4,2)) AS [Query Count Percentage], SUM(CPU) AS [CPU Query Total], AVG(CPU) AS [CPU Per Query], CAST(SUM(CPU) * 100.0 / (SELECT TOP 1 [Total CPU] FROM [Total All Queries]) AS DECIMAL(4,2)) AS [CPU Query Percentage], SUM(Reads) AS [Reads Query Total], AVG(Reads) AS [Reads Per Query], CAST(SUM(Reads) * 100.0 / (SELECT TOP 1 [Total Reads] FROM [Total All Queries]) AS DECIMAL(4,2)) AS [Reads Query Percentage], SUBSTRING(Textdata, 1, 150) AS Query FROM My_Database GROUP BY DatabaseName, SUBSTRING(Textdata, 1, 150) ORDER BY [Reads Query Total] DESC
After you have run this and identified a query for optimization, you’ll need to query the database again so you can get the entire query at issue. Identify something unique in the query and use that as a comparison. (In my experience, I have had to compare on individual terms.)
SELECT CPU, Reads, DatabaseName, TextData AS Query,* FROM Baseline_Reads_5000 WHERE Baseline_Reads_5000.Textdata like '%part of query%' ORDER BY Baseline_Reads_5000.CPU DESC
- Analyze Expensive Queries in Database Engine Tuning Adviser
You can copy and paste queries from your Baseline database into a new query window, then select the query, right mouse button click, and select “Analyze Query in Database Engine Tuning Adviser”. This will show any recommendations for new indexes or statistics that would help optimize the query. It also gives you a projected percentage of optimization that can be achieved.
If it recommends a new index and a few statistics that are pretty small that is projected to yield a high improvement, then you’re probably in good shape. If it recommends very large indexes to achieve small results or if it doesn’t offer any recommendations, then you have more work to do.
Sometimes a particular column is indexed on one table, but your query is looking for it on a different table. Changing the query to use an index that already exists on the column in a different table can give you substantial improvements without needing to create any new indexes.
Sometimes the query is just not well written. In those cases, you may need to break up the query or think of a different method to obtain the same results.
- Profile the Results of the Optimizations
Sometimes you can see a very significant difference by just running a query in SQL Server Management Studio before and after, especially for very expensive queries. With moderately expensive queries, though, it may be helpful to obtain more precise numbers.
It is possible to run SQL Profiler and restrict the results to your machine. Alternatively, you can isolate a test database and run the query there. If you’re using Linq, then you will need to get the new generated SQL to compare or just run it in a development environment that you can isolate.
For this run of SQL Profiler, you don’t have to write your results to a database table, since the rows should be minimal enough to view onscreen. It can still be nice to have for later reference, though, so you can name the table something like “Optimize Registrations”.
Still, you can see the difference your changes make right in the Profiler window. Sometimes the first run will show up, but the changes are so significant that the second run (with the new index or whatever) will be below the threshold you set. So, for these runs, it’s good to set a lower threshold of reads and/or CPU.
Additionally, watching the impact of a specific event on the database can identify redundant queries–queries that are run multiple times to get the same data. Storing the query results the first time can provide very significant decreases in database usage. Also, every access of the database requires some overhead, so accessing the database a hundred times to get a small piece of information may be more expensive to accessing it once to get a hundred small pieces of information.
- Read and CPU Thresholds
After you’ve optimized your most expensive queries, you may need to lower these to get more results. However, at some point the gains you achieve will not be worth the amount of effort it takes. At that point, set a reminder to come back in a few months and run another profile to see if any new queries have been introduced that are not properly optimized.
- Complex Queries
Not all expensive queries can be resolved by adding indexes. Sometimes a query is just too complex and needs to be broken up into smaller queries. For instance, a long OR statement like “(@value1 = -1 AND IndexedColumn2 = @value2) OR (@value1 > -1 AND IndexedColumn1 = @value1) can render the indexing of columns of no use.
- Random Activity Profiling and Planned Activity Profiling
Random Activity Planning: When you first start out, it’s probably good to just profile the system as people are using it. This will measure random activity of your users. It may not be best to start profiling during your highest volume time, since you don’t want to overload the system, so pick an average load time at first. Eventually, though, it would be good to profile high activity times.
Planned Activity Profiling: During a less active time or in a development environment, it is a good idea to do some profiling on specific actions which may not randomly be performed by users in a particular window of profiling. They may, however, occur occasionally during your peak hours, and if they involve very expensive queries, they can really slow down everyone’s experience. So, profiling a period of time in which rare but possibly expensive queries are explicitly run can be very critical.
P.S. You may also find this post helpful that describes Highly Inefficient Linq Queries that Break Database Indexing
For more tips on managing a SQL Server Database, see Managing a SQL Server Database: Tips for Beginners