SQL Server Performance Tuning for SQL Server Developers

Tuesday Oct 3rd 2000 by Brad McGehee

Don't think that performance tuning your SQL Server applications is regulated to the end of the development process. If you want your SQL Server-based applications to scale and run at their full potential, you must begin considering scalability and performance issues during the early stages of your application's development.

Don't think that performance tuning your SQL Server applications is regulated to the end of the development process. If you want your SQL Server-based applications to scale and run at their full potential, you must begin considering scalability and performance issues during the early stages of your application's development.

If you have been a DBA or SQL developer for very long, then you have probably run across some slow SQL Server-based applications. And often when this happens, everybody begins blaming everybody else for the problem. It's the network. It's the server hardware. It's SQL Server. It's the users. It's the database. And this goes on and on, but unfortunately, blame doesn't fix slow applications. The cure to most slow SQL Server-based applications is prevention, which includes careful up front analysis of the user's needs, thoughtful design, optimal coding, and appropriate implementation.

For any application, SQL Server or otherwise, scalability and performance have to be built in from the very beginning. Once the application is rolled out, it is very difficult and expensive to resolve most scalability and performance issues.

In this article you are going to learn the fundamentals of how to design, code, and implement scalable and performance optimized SQL Server applications. You won't learn everything, as that would take an entire book. The focus of this article is on learning the very minimum you must know in order to produce scalable and performance tuned SQL Server-based applications. Here's what you will learn:

  • What Every Developer and DBA Must Know About SQL Server Performance Tuning

  • How to Optimize Your Server's Hardware

  • How to Optimize SQL Server's Configuration Settings

  • How to Optimize Your Application's Design

  • How to Optimize Your Database's Design

  • How to Optimize Your Application Code for SQL Server

  • How to Optimize Your Transact-SQL Code

  • How to Select Indexes for Optimal Database Performance

  • How to Take Advantage of SQL Server Performance Tuning Tools

At the very least, if you take advantage of the advice and information in this article, you will find that performance tuning your SQL Server-related applications is not a big as mystery as you might think. So let's get to work.


What Every Developer Must Know About SQL Server Performance Tuning
As a developer, there are some overriding principals on which to proceed. This section introduces these principals. Keep these in mind as you read about specific performance tuning details discussed later in this article, and whenever performance tuning your SQL Server applications.

Performance Tuning is Not a Science
SQL Server performance tuning is more art than science. I am sure you didn't want to hear that, but this is a fact of life. I wish I could tell you exactly, step-by-step, what you need to do to make your applications scale and perform well. The problem, as you probably already know, is that any modern software application is a combination of many complex variables. Unfortunately, no matter how hard you try, you don't have full control of your application and the environment it runs under. For example, here are some (not all) of the factors that affect an application's performance:

  • SQL Server (the program itself)

  • SQL Server's Configuration Settings

  • The Application's Transact-SQL Code

  • The Application's non-Transact-SQL Code

  • The Database's Design

  • The Operating System (server and client)

  • The Middleware (Microsoft Transaction Server, Microsoft Messaging Server)

  • The Hardware (server and client)

  • The Network Hardware and Bandwidth (LAN and WAN)

  • The Number of Clients

  • The Client Usage Patterns

  • The Type and Quantity of Data Stored in SQL Server

  • Whether the Application is OLTP- or OLAP-based

While it is virtually impossible to control every factor that influences SQL Servers' scalability and performance, what you can do is make the most of what you can control.

Test During All Stages of Your Application's Development
Scalability and performance testing should not only be done after the application is written and ready to be rolled out. Testing should be an integral part of the development process, beginning with the earliest stages of the application and database design, and continuing as appropriate throughout the entire process. Most scalability and performance issues are a result of poor initial design, and can only be prevented early in the game. If you wait until after the application is complete, you will either have to live with performance problems, or rewrite the application.

When performing tests, always proceed scientifically, only testing one dependant variable at a time. For example, if you suspect that you need to add an index to a table to boost performance, but you are not sure which one, or of what type is best, experiment with only one change at a time, testing each change individually to see if it produces the results you expect. If you change more than one thing at a time, you won't know which change you made worked or didn't work. This goes for all testing, whether it is adding indexes, making SQL Server configuration changes, or testing various hardware configurations.

Always try to test under realistic conditions. This means use "real" data, testing against the largest expected data sets, and using hardware similar to the hardware that will be used when the application goes into production. If you don't, you may be surprised that while your application works well for 10 simultaneous users during testing, that it fails miserably when 500 users are online.

Not All Performance Issues are Obvious
If you do much performance tuning, you will soon realize that many performance tuning and scalability issues are not so obvious. This is because many performance-related problems are caused by two or more problems, not a single obvious problem. This makes it difficult to isolate and fix the problem. While there are no easy solutions, one of the best approaches to take is to isolate and correct one problem at a time, until you have found and fixed them all.

Not All Performance Tuning Suggestions Work In All Cases
In this article, and from other performance tuning sources, you will find dozens of ideas and tips on performance tuning. Keep in mind that in many cases a performance tuning suggestion will work great in one particular situation, but could actually reduce performance under a different situation. This is because many performance tuning suggestions are situation specific. As the person responsible for performance tuning, you will need to evaluate each tip or suggestion you run across and decide whether it is applicable to your particular situation. In other words, don't blindly proceed with a performance tuning tip. Be sure you understand its implications before you use it.

SQL Server Performance Tuning is a Learned Skill
Learning how to master SQL Sever 2000 performance tuning cannot be learned overnight. In fact, experience, more than book learning, is how you will master this skill. But in order to take advantage of the experience you gain over time, it is also important to be conversant in the fundamentals of the technologies that affects your application's performance.

For example, you need to fully understand the programming language used to write your application, database design, application design, Transact-SQL, how SQL Server stores and indexes data, and how networks and server hardware really work. The better understanding you have of the basics of the applicable technologies used to develop and roll out your application, the better position you will be in to understand what is causing performance and scalability problems and how to resolve them. Learn all you can.


How to Optimize Your Server's Hardware
When it comes time to blame poor application performance on something, server hardware gets a disproportionate amount of blame. What is ironic, is that in most cases the hardware is not the main cause of the problem. In fact, server hardware plays a much smaller role than most people think when it comes to SQL Server-based application performance and scalability.

The reason for this is that most slow applications are slow because of poor up front design, not because of slow hardware. The reason hardware is often blamed is because performance problems often don't show themselves until after the application is rolled out. And since the application's design can't be changed at this time, about the only thing you can try to help boost performance is to throw hardware at it. While hardware can help, it usually doesn't fully resolve the problem, and this is why hardware is often blamed for slow performance. While hardware can sometimes be an issue, most likely it is not.

In order to prevent your server hardware from being a drag on your SQL Server-based application (which it can if it is inappropriately selected or configured), let's take a brief look at some of the most common hardware selection and tuning issues.

Selecting Hardware
Selecting the optimum hardware for your SQL Server-based application depends on a variety of factors, such as the size of the database, the number of users, how the database is used (OLTP or OLAP), and others. While there is no sure-fire formula for sizing server hardware, the best way to get a feel for sizing is to test your application early in the development stage. Ah, testing is mentioned again. That's right. While many experienced DBAs can probably give you a good estimate on the optimum hardware you need, only through realistic testing will you know for sure what hardware is required to meet your application's needs.

When is comes to server hardware, here are some things to keep in mind:

  • CPU: Always purchase a server with the ability to expand its number of CPUs. For example, if testing indicates that a single CPU server will be adequate, purchase a server with at least room for two CPUs, even if you only use one of the slots. The same goes for larger servers with four or more CPUs. Always leave room for growth.

  • Memory: This is probably the most significant piece of hardware that affects SQL Server's performance. Ideally, your entire database should fit into RAM. Unfortunately, this is not often possible. At the very minimum, try to get enough RAM to hold the largest table you expect to have, and if you can afford it, get all the RAM your server can handle, which is often 2GB or more. There is no such thing as too much RAM.

  • I/O Subsystem: After RAM, the I/O subsystem is the most important piece of hardware to affect SQL Server's performance. At the very minimum, purchase hardware-based RAID for your databases. As a rule of thumb, you will to purchase more, smaller drives, not fewer, larger drives in your array. The more disks that are in an array, the faster I/O will be.

  • Network Connection: At the server, have at least one 100Mbs network card, and it should be connected to a switch. Ideally, you should have two network cards in the server connected to a switch in full-duplex mode.

Tuning the Server
Even the most expensive server hardware won't perform well if it is not configured and tuned correctly. I have seen many hardware-related performance problems caused as the result of not using Microsoft NT Server approved hardware and drivers. Some of these types of hardware performance-related issues are very difficult to trace and resolve. Ideally, ensure that you hardware, including NT, is correctly installed and configured by a competent technician. Then test your application under controlled conditions to test for potential performance issues before it is used in production.

Your operating system must also be configured correctly. This includes many things, too many to describe here. Just as with the hardware, ensure that the operating system is properly configured and tested before it is put into production.

For best performance on a server, SQL Server should be the only application running on the server, other than management utilities. Don't try to save a few bucks by putting your IIS or MTS server on the same server as SQL Server. Not only does this hurt SQL Server's performance, but it also makes it more difficult to performance tune and troubleshoot SQL Server.

How to Optimize SQL Server's Configuration Settings
Another common misconception about tuning SQL Server is that you must fine-tune its various configuration settings in order to get optimum performance. While there was some truth to this in earlier versions of SQL, this is no longer much of an issue, except on the very largest and busiest of servers.

For the most part, SQL Server is self-tuning. What does this mean? It means that SQL Server observes what is running on itself, and automatically makes internal adjustments which, for the most part, keep SQL Server running as optimally as possible given the tasks at hand and the given hardware.

When you perform performance testing on SQL Server, keep in mind that SQL Server can take some time before it adjusts itself optimally. In other words, the performance you get immediately after starting the SQL Server service, and the performance you get a couple of hours later after a typical workload has been running, can be different. Always perform your testing after SQL Server has had a chance to adjust itself to your workload.

There are 36 SQL Server configuration options that can be changed using either the Enterprise Manager or the sp_configure stored procedure. Unless you have a lot of experience tuning SQL Server, I don't recommend you change any of SQL Server's settings. As a novice, you may make a change that could in fact reduce performance. This is because when you change a setting, you are "hard-coding" the setting from then on. SQL Server has the ability to change its setting on the fly, based on the current workload. But once you "hard-code" a setting, you partially remove SQL Server's ability to self-tune itself.

If after serious consideration you feel that making a change to one or more SQL Server configuration settings can boost performance in your particular environment, then you will want to proceed slowly and cautiously. Before you make the setting change, you will first want to get a good baseline on the SQL Server's performance, under a typical workload, using a tool such as Performance Monitor (discussed later). Then make only one change at a time. Never make more than one change at a time, because if you do, you won't know which change, if any of them, made a difference.

Once the one change is made, again measure SQL Server's performance under the same workload to see if performance was actually boosted. If it wasn't, which will often be the case, then change back to the default setting. If there was a performance boost, then continue to check to see if the boost in performance continues under other workloads the server experiences over time. Your later testing may show that your change helps some workloads, but hinders others. This is why changing most configuration settings is not recommended.

In any event, if your application is suffering from a performance-related issue, the odds of a configuration change resolving it are quite low.

How to Optimize Your Application's Design
If you are using an n-tier design for your application, and who isn't for most large-scale applications these days, SQL Server is just one part of a larger application. And perhaps more important than you realize, how your implement your n-tier design affects your application's performance more than SQL Server itself. Unfortunately, SQL Server often gets more of the blame for poor performance than the application design, even when it is usually the application's design that is causing most of the performance problems. What I hope to do here is offer a few suggestions that may aide you in your application design, helping to prevent SQL Server from getting all the blame for poor performance. So let's start.

One of the first steps you must decide when designing an n-tier application is to select the logical and physical design. Of the two, the physical design is where most of the mistakes are made when it comes to performance. This is because this is where the theory (based on the logical design) has to be implemented in the real world. And just like anything else, you have many choices to make. And many of these choices don't lend themselves to scalability or high performance.

For example, do you want to implement a physical two-tier implementation with fat clients, a physical two-tier implementation with a fat server, a physical three-tier implementation, an Internet implementation, or some other implementation? Once you decide this question, then you must ask yourself, what development language will be used, what browser, will you use Microsoft Transaction Server (MTS), will you use Microsoft Message Queue Server (MSMQ), and on and on.

Each of these many decisions can and will affect performance and scalability. Because there are so many options, it is again important to test potential designs early in the design stage, using rapid prototyping, to see which implementation will best meet your user's needs.

More specifically, as you design your physical implementation, try to follow these general recommendations to help ensure scalability and optimal performance in your application:

  • Perform as many data-centered tasks as possible on SQL Server in the form of stored procedures. Avoid manipulating data at the presentation and business services tiers.

  • Don't maintain state (don't store data from the database) in the business services tier. Maintain state in the database as much as possible

  • Don't create complex or deep object hierarchies. The creation and use of complex classes or a large number of objects used to model complex business rules can be resource intensive and reduce the performance and scalability of your application. This is because the memory allocation when creating and freeing these objects is costly.

  • Consider designing the application to take advantage of database connection pooling and object pooling using Microsoft Transaction Server (MTS). MTS allows both database connections and objects to be pooled, greatly increasing the overall performance and scalability of your application.

  • If your application runs queries against SQL Server that by nature are long, design the application to be able to run queries asynchronously. This way, one query does not have to wait for the next before it can run. One way to build in this functionality into your n-tier application is to use the Microsoft Message Queue Server (MSMQ).

While following these suggestions won't guarantee a scalable and fast performing application, they are a good first start.

How to Optimize Your Database's Design
Like application design, database design is very critical to the scalability and performance of your SQL Server applications. And also like application design, if you don't do a good job in the first place, it is very hard and expensive to make changes after your application has gone into production. Here are some key things to keep in mind when designing SQL Server databases for scalability and performance.

As always, you will want to test your design as early as possible using realistic data. This means you will need to develop prototype databases with sample data, and test the design using the type of activity you expect to see in the database once production starts.

One of the first design decisions you must make is whether the database will be used for OLTP or OLAP. Notice that I said "or". One of the biggest mistakes you can make when designing a database is to try to meet the needs of both OLTP and OLAP. These two types of applications are mutually exclusive in you are interested in any sense of high performance and scalability.

OLTP databases are generally highly normalized, helping to reduce the amount of data that has to be stored. The less data you store, the less I/O SQL Server will have to perform, and the faster database access will be. Transactions are also kept as short as possible in order to reduce locking conflicts. And last of all, indexing is generally minimized to reduce the overhead of high levels of INSERTs, UPDATEs, and DELETEs.

OLAP databases, on the other hand, are highly de-normalized. In addition, transactions are not used, and because the database is read-only, record locking is not an issue. And of course, heavy indexing is used in order to meet the wide variety of reporting needs.

As you can see, OLTP and OLAP databases serve two completely different purposes, and it is virtually impossible to design a database to handle both needs. While OLAP database design is out of this book's scope, I do want to mention a couple of performance-related suggestions in regard to OLTP database design.

When you go through the normalization process when designing your OLTP databases, your initial goal should be to fully normalize it according to the three general principles of normalization. The next step is to perform some preliminary performance testing, especially if you foresee having to perform joins on four or more tables at a time. Be sure to test using realistic sample data.

If performance is acceptable, then don't worry about having to join four or more tables in a query. But if performance is not acceptable, then you may want to do some selective de-normalization of the tables involved in order to reduce the number of joins used in the query, and to speed performance.

It is much easier to catch a problem in the early database design stage, rather than after the finished application has been rolled out. De-normalization of tables after the application is complete is nearly impossible. One word of warning. Don't be tempted to de-normalize your database without thorough testing. It is very hard to deduce logically what de-normalization will do to performance. Only through realistic testing can you know for sure if de-normalization will gain you anything in regards to performance.

How to Optimize Your Application Code for SQL Server
At some point during the development process you will have to begin coding your application to work with SQL Server. By this time, the application and database designs should have already been completed and tested for performance and scalability using rapid prototyping techniques.

How your code your application has a significant bearing on performance and scalability, just as the database design and the overall application design affect performance and scalability. Sometimes, something as simple as choosing one coding technique over another can make a significant different. Rarely is there only one way to code a task, but often there is only one way to code a task for optimum performance and scalability.
What I want to do in this section is focus on some essential techniques that can affect the performance of your application and SQL Server.

Since I don't know what development language you will be using, I am going to assume here that you will be using Microsoft's ADO (Active Data Objects) object model to access SQL Server from your application. The examples I use here should work for most Visual Basic and ASP developers. So let's just dive in and look at some specific techniques you should implement in your application code when accessing SQL Server data to help ensure high performance.

Use OLE DB to Access SQL Server
You can access SQL Server data using either ODBC or OLE DB. Which method you use depends on how you specify the connection string when you use ADO to connect to SQL Server. For best performance, always select OLE DB. OLE DB is used natively by SQL Server, and is the most effective way to access any SQL Server data.
Along these same lines, when creating an ADO connection to SQL Server, you can either use a DSN in the connection string, or you can use a DSN-less connection. For optimal performance, use DSN-less connections. Using them prevents the need for the OLE DB driver to look up connection string information in the registry of the client the application code is running on, saving some overhead.

Encapsulate your DML (Data Manipulation Language) in Stored Procedures
ADO allows you three different ways to SELECT, INSERT, UPDATE, or DELETE data in a SQL Server database. You can use ADO's methods, you can use dynamic SQL, or you can use stored procedures. Let's take a brief look at each of these.

The easiest way to manipulate data from your application is to use ADO's various methods, such as rs.AddNew, rs.Update, or rs.Delete. While using these methods is easy to learn and implement, you pay a relatively steep penalty in overhead for using them. ADO's methods often create slow cursors and generate large amounts of network traffic. If your application is very small, you would never notice the difference. But if your application has much data at all, your application's performance could suffer greatly.

Another way to manipulate data stored in SQL Server using ADO is to use dynamic SQL (also sometimes referred to as ad hoc queries). Here, what you do is send Transact-SQL in the form of strings from ADO in your application to be run on SQL Server. Using dynamic SQL is generally much faster than using ADO's methods, although it does not offer the greatest performance. When SQL Server receives the dynamic SQL from your ADO-based application, it has to compile the Transact-SQL code, create a query plan for it, and then execute it. Compiling the code and creating the query plan the first time takes a little overhead. But once the Transact-SQL code has been compiled and a query plan created, it can be reused over and over assuming the Transact-SQL code sent later is nearly identical, which saves overhead.

For optimal performance, you will want to use ADO to called stored procedures on your server to perform all your data manipulation. The advantages of stored procedures are many. Stored procedures are already pre-compiled and optimized, so this step doesn't have to be repeated every time the stored procedure is run. The first time a stored procedure is run, a query plan is created and stored in SQL Server's memory, so it can be reused, saving even more time. Another benefit of stored procedures is that they help reduce network traffic and latency. When your application's ADO code calls a stored procedure on SQL Server, it makes a single network call. Then any required data processing is performed on SQL Server, where data processing is most efficiently performed, and then if appropriate, it will return any results to your application. This greatly reduces network traffic and increases scalability and performance.

While stored procedures handle basic data manipulation like a champ, they can also handle much more very well. Stored procedures can run virtually any Transact-SQL code, and since Transact-SQL code is the most efficient way to manipulate data, all of your application's data manipulations should be done inside of stored procedures on SQL Server, not in COM components in the business-tier or on the client.

When you use ADO to execute stored procedures on SQL Server, you have two major ways to proceed. You can use ADO to call the Refresh method of the Parameters collection in order to save you a little coding. ADO needs to know what parameters are used by the stored procedure, and the Refresh method can query the stored procedure on SQL Server to find out the parameters. But as you might expect, this produces additional network traffic and overhead. While it takes a little more coding, a more efficient way to call a SQL Server stored procedure is to create the parameters explicitly in your code. This eliminates the extra overhead caused by the Refresh method and speeds up your application.

Encapsulate Your ADO Code in COM Components
As part of creating a scalable and optimized n-tier applications, put the ADO code that accesses SQL Server data into COM components. This is true whether your front end is a Visual Basic application or a web-based ASP application. This gives you all the standard benefits of COM components, such as object pooling using MTS. And for ASP-based applications, it provides greater speed because the ADO code in COM objects is already compiled, unlike ADO code found in ASP pages. How you implement your data manipulation code in COM components should be considered when the application is first designed.

When designing COM objects, make them stateless as possible, avoiding the use of properties. Instead, use methods to perform your data-related tasks. This is especially critical if you use MTS, as any objects that preserve state can significantly reduce MTS's ability to scale, while at the same time, increasing overhead and hurting performance.

For optimum performance, COM objects should be compiled as in-process DLLs (which is required if they are to run under MTS). You should always employ early binding when referencing COM objects, and create them explicitly, not implicitly.


How to Optimize Your Transact-SQL Code
Transact-SQL, just like any programming language, offers more than one way to perform many tasks. And as you might imagine, some techniques offer better performance than others. In this section you will learn some of the "tricks-of-the-trade" when it comes to writing high performing Transact-SQL code.

Choose the Appropriate Data Types
While you might think that this topic should be under database design, I have decided to discuss it here because Transact-SQL is used to create the physical tables that were designed during the earlier database design stage.

Choosing the appropriate data types can affect how quickly SQL Server can SELECT, INSERT, UPDATE, and DELETE data, and choosing the most optimum data type is not always obvious. Here are some suggestions you should implement when creating physical SQL Server tables to help ensure optimum performance.

  • Always choose the smallest data type you need to hold the data you need to store in a column. For example, if all you are going to be storing in a column are the numbers 1 through 10, then the TINYINT data type is more appropriate that the INT data type. The same goes for CHAR and VARCHAR data types. Don't specify more characters for character columns that you need. This allows SQL Server to store more rows in its data and index pages, reducing the amount of I/O needed to read them. Also, it reduces the amount of data moved from the server to the client, reducing network traffic and latency.

  • If the text data in a column varies greatly in length, use a VARCHAR data type instead of a CHAR data type. Although the VARCHAR data type has slightly more overhead than the CHAR data type, the amount of space saved by using VARCHAR over CHAR on variable length columns can reduce I/O, improving overall SQL Server performance.

  • Don't use the NVARCHAR or NCHAR data types unless you need to store 16-bit character (Unicode) data. They take up twice as much space as VARCHAR or CHAR data types, increasing server I/O overhead.

  • If you need to store large strings of data, and they are less than 8,000 characters, use a VARCHAR data type instead of a TEXT data type. TEXT data types have extra overhead that drag down performance.

  • If you have a column that is designed to hold only numbers, use a numeric data type, such as INTEGER, instead of a VARCHAR or CHAR data type. Numeric data types generally require less space to hold the same numeric value as does a character data type. This helps to reduce the size of the columns, and can boost performance when the columns is searched (WHERE clause) or joined to another column.

Use Triggers Cautiously
Triggers can be a powerful tool in Transact-SQL, but since they execute every time that a table is INSERTED, UPDATED, or DELETED (depending on how the trigger is created), they can produce a lot of overhead. Here's some tips on how to optimize trigger performance.

  • Keep the code in your triggers to the very minimum to reduce overhead. The more code that runs in the trigger, the slower each INSERT, UPDATE, and DELETE that fires it will be.

  • Don't use triggers to perform tasks that can be performed using more efficient techniques. For example, don't use a trigger to enforce referential integrity if SQL Server's built-referential integrity is available to accomplish your goal. The same goes if you have a choice between using a trigger or a CHECK constraint to enforce rules or defaults. You will generally want to choose a CHECK constraint as they are faster than using triggers when performing the same task.

  • Try to avoid rolling back triggers because of the overhead involved. Instead of letting the trigger find a problem and rollback a transaction, catch the error before it can get to the trigger (if possible based on your code). Catching an error early (before the trigger fires) consumes fewer server resources than letting the trigger roll back.

Don't Access More Data Than You Need
While this suggestion may sound obvious, it must not be, because this is a common performance-related issue I find over and over again in many SQL Server-based applications. Here are some ideas on how to minimize the amount of data that is returned to the client.

  • Don't return more columns or rows of data to the client than absolutely necessary. This just increases disk I/O on the server and network traffic, both of which hurts performance. In SELECT statements, don't use SELECT * to return rows, always specify in your SELECT statement exactly which columns are needed to be returned for this particular query, and not a column more. In most cases, be sure to include a WHERE clause to reduce the number or rows sent to only those rows the clients needs to perform the task immediately at hand.

  • If your application allows users to run queries, but you are unable in your application to easily prevent users from returning hundreds, even thousands of unnecessary rows of data they don't need, consider using the TOP operator within the SELECT statement. This way, you can limit how may rows are returned, even if the user doesn't enter any criteria to help reduce the number or rows returned to the client.

Avoid Using Cursors
Transact-SQL is designed to work best on result sets, not on individual records. That's where cursors come into play. They allow you to process individual records. The only problem with individual record processing is that it is slow. Ideally, for high-performing SQL Server-based applications, cursors should be avoided.

If you need to perform row-by-row operations, try to find another method to perform the task. Some options are to perform row-by-row tasks at the client instead of the server, using tempdb tables at the server, or using a correlated sub-query.

Unfortunately, these are not always possible, and you have to use a cursor. If you find it impossible to avoid using cursors in your applications, then perhaps one of these suggestions will help.

  • SQL Server offers you several different types of cursors, each with its different performance characteristics. Always select the cursor with the least amount of overhead that has the features you need to accomplish your goals. The most efficient cursor you can choose is the fast forward-only cursor.

  • When using a server-side cursor, always try to fetch as small a result set as possible. This includes fetching only those rows and columns the client needs immediately. The smaller the cursor, no matter what type of server-side cursor it is, the fewer resources it will use, and performance will benefit.

  • When you are done using a cursor, don't just CLOSE it, you must also DEALLOCATE it. Deallocation is required to free up the SQL Server resources used by the cursor. If you only CLOSE the cursor, locks are freed, but SQL Server resources are not. If you don't DEALLOCATE your cursors, the resources used by the cursor will stay allocated, degrading the performance of your server until they are released.

Use Joins Appropriately
Table joins can be a big contributor of performance problems, especially if the joins include more than two tables, or if the tables are very large. Unfortunately, joins are a fact of life in relational databases. Because they are so common, you will need to take extra time to help ensure that your joins are as optimal as possible. Here are some tips to help.

  • If you have two or more tables that are frequently joined together, then the columns used for the joins should have an appropriate index. If the columns used for the joins are not naturally compact, then considering adding surrogate keys to the tables that are compact in order to reduce the size of the keys, thus decreasing read I/O during the join process, and increasing overall performance. You will learn more about indexing in the next section of this article.

  • For best performance, the columns used in joins should be of the same data types. And if possible, they should be numeric data types rather than character types.

  • Avoid joining tables based on columns with few unique values. If columns used for joining aren't mostly unique, then the SQL Server optimizer will perform a table scan for the join, even if an index exists on the columns. For best performance, joins should be done on columns that have unique indexes.

  • If you have to regularly join four or more tables to get the recordset you need, consider denormalizing the tables so that the number of joined tables is reduced. Often, by adding one or two columns from one table to another, joins can be reduced.

Encapsulate Your Code in Stored Procedures
Virtually all of the Transact-SQL used in your SQL Server-based applications should be encapsulated in stored procedures, not run as dynamic SQL or scripts. This not only reduces network traffic (only the EXECUTE or CALL is issued over the network between the client and SQL Server), but it speeds up the Transact-SQL because the code in the stored procedure residing on the server is already pre-compiled. Here are a couple of things to keep in mind when writing stored procedures for optimal performance.

When a stored procedure is first executed (and it does not have the WITH RECOMPILE option specified), it is optimized and a query plan is compiled and cached in SQL Server's memory. If the same stored procedure is called again, it will use the cached query plan instead of creating a new one, saving time and boosting performance. This may or may not be what you want. If the query in the stored procedure is the same each time, then this is a good thing. But if the query is dynamic (the WHERE clauses changes substantially from one execution of the stored procedure to the next), then this is a bad thing, as the query will not be optimized when it is run, and the performance of the query can suffer.

If you know that your query will vary each time it is run from the stored procedure, you will want to add the WITH RECOMPILE option when you create the stored procedure. This will force the stored procedure to be re-compiled each time it is run, ensuring the query is optimized each time it is run.

Always include in your stored procedures the statement, "SET NOCOUNT ON". If you don't turn this feature on, then every time a SQL statement is executed, SQL Server will send a response to the client indicating the number of rows affected by the statement. It is rare that the client will ever need this information. Using this statement helps reduce the traffic between the server and the client.

Deadlocking can occur within a stored procedure when two user processes have locks on separate objects and each process is trying to acquire a lock on the object that the other process has. When this happens, SQL Server ends the deadlock by automatically choosing one and aborting the process, allowing the other process to continue. The aborted transaction is rolled back and an error message is sent to the user of the aborted process.

To help avoid deadlocking in your SQL Server application, try to design your application using these suggestions: 1) have the application access server objects in the same order each time; 2) during transactions, don't allow any user input. Collect it before the transaction begins; 3) keep transactions short and within a single batch, and 4) if appropriate, use as low of an isolation level as possible for the user connection running the transaction.

How to Select Indexes for Optimal Database Performance
Index selection is a mystery for many SQL Server DBAs and developers. Sure, we know what they do and how they boost performance. The problem often is how to select the ideal type of index (clustered vs. non-clustered), the number of columns to index (do I need multi-column indexes?), and which columns should be indexed.

In this section we will take a brief look at how to answer the above questions. Unfortunately, there is no absolute answer for every occasion. Like much of SQL Server performance tuning and optimization, you may have to do some experimenting to find the ideal indexes. So let's begin by looking as some general index creation guidelines, then we will take a more detailed look at selecting clustered and non-clustered indexes.

Is There Such a Thing as Too Many Indexes?
Yes. Some people think that all you have to do is index everything, and then all of your performance issues will go away. It doesn't work that way. Just as an index can speed data access, it can also degrade access if it is inappropriately selected. The problem with extra indexes is that SQL Server must maintain them every time that a record is INSERTED, UPDATED, or DELETED from a table. While maintaining one or two indexes on a table is not too much overhead for SQL Server to deal with, if you have four, five, or more indexes, they can be a large performance burden on tables. Ideally, you want to have as few as indexes as you can. It is often a balancing act to select the ideal number of indexes for a table in order to find optimal performance.

As a general rule of thumb, don't automatically add indexes to a table because it seems like the right thing to do. Only add indexes if you know that they will be used by the queries run against the table. If you don't know what queries will be run against your table, then don't add any indexes until you know for sure. It is too easy to make a guess on what queries will be run, create indexes, and then later find out your guesses were wrong. You must know the type of queries that will be run against your data, and then these need to be analyzed to determine the most appropriate indexes, and then the indexes must be created and tested to see if they really help or not.

The problem of selecting optimal indexes is often difficult for OLTP applications because they tend to experience high levels of INSERT, UPDATE, and DELETE activity. While you need good indexes to quickly locate records that need to be SELECTED, UPDATED, or DELETED, you don't want every INSERT, UPDATE, or DELETE to result in too much overhead because you have too many indexes. On the other hand, if you have an OLAP application that is virtually read-only, then adding as many indexes as you need is not a problem because you don't have to worry about INSERT, UPDATE, or DELETE activity. As you can see, how your application is used makes a large difference in your indexing strategy.

Another thing to think about when selecting indexes is that the SQL Server Query Optimizer may not use the indexes you select. If the Query Optimizer chooses not to use your indexes, then they are a burden on SQL Server and should be deleted. So how come the SQL Server Query Optimizer won't always use an index if one is available?

This is too large a question to answer in detail here, but suffice to say, sometimes it is faster for SQL Server to perform a table scan on a table than it is to use an available index to access data in the table. Two reasons that this may happen is because the table is small (not many rows), or if the column that was indexed isn't at least 95% unique. How do you know if SQL Server won't use the indexes you create? We will answer this question a little later when we take a look at how to use the SQL Server Query Analyzer later in this article.

Tips for Selecting a Clustered Index
Since you can only create one clustered index per table, take extra time to carefully consider how it will be used. Consider the type of queries that will be used against the table, and make an educated guess as to which query is the most critical, and if this query will benefit from having a clustered index.
In general, use these rules of thumb when selecting a column for a possible clustered index.

  • The primary key you select for your table should not always be a clustered index. If you create the primary key and don't specify otherwise, then SQL Server automatically makes the primary key a clustered index. Only make the primary key a clustered index if it meets one of the following recommendations.

  • Clustered indexes are ideal for queries that select by a range of values or where you need sorted results. This is because the data is already presorted in the index for you. Examples of this include when you are using BETWEEN, <, >, GROUP BY, ORDER BY, and aggregates such as MAX, MIN, and COUNT in your queries.

  • Clustered indexes are good for queries that look up a record with a unique value (such as an employee number) and when you need to retrieve most or all of the data in the record. This is because the query is covered by the index.

  • Clustered indexes are good for queries that access columns with a limited number of distinct values, such as a columns that holds country or state data. But if column data has little distinctiveness, such as columns with a yes or no, or male or female, then these columns should not be indexed at all.

  • Clustered indexes are good for queries that use the JOIN or GROUP BY clauses.

  • Clustered indexes are good for queries where you want to return a lot of rows, just not a few. This is because the data is in the index and does not have to be looked up elsewhere.

  • Avoid putting a clustered index on columns that increment, such as an identity, date, or similarly incrementing columns, if your table is subject to a high level of INSERTS. Since clustered indexes force the data to be physically ordered, a clustered index on an incrementing column forces new data to be inserted at the same page in the table, creating a table hot spot, which can create disk I/O bottlenecks. Ideally, find another column or columns to become your clustered index.

What can be frustrating about the above advice is that there might be more than one column that should be clustered. But as we know, we can only have one clustered index per table. What you have to do is evaluate all the possibilities (assuming more than one column is a good candidate for a clustered index) and then select the one that provides the best overall benefit.

Tips for Selecting Non-Clustered Indexes
Selecting non-clustered indexes is somewhat easier than clustered indexes because you can created as many as is appropriate for your table. Here are some tips for selecting which columns in your tables might be helped by adding non-clustered indexes.

  • Non-clustered indexes are best for queries that return few rows (including just one row) and where the index has good selectivity (above 95%).

  • If a column in a table is not at least 95% unique, then most likely the SQL Server Query Optimizer will not use a non-clustered index based on that column. Because of this, don't add non-clustered indexes to columns that aren't at least 95% unique. For example, a column with "yes" or "no" as the data won't be at least 95% unique.

  • Keep the "width" of your indexes as narrow as possible, especially when creating composite (multi-column) indexes. This reduces the size of the index and reduces the number of reads required to read the index, boosting performance.

  • If possible, try to create indexes on columns that have integer values instead of characters. Integer values have less overhead than character values.

  • If you know that your application will be performing the same query over and over on the same table, consider creating a covering index on the table. A covering index includes all of the columns referenced in the query. Because of this, the index contains the data you are looking for and SQL Server doesn't have to look up the actual data in the table, reducing logical and/or physical I/O. On the other hand, if the index gets too big (too many columns), this can increase I/O and degrade performance.

  • An index is only useful to a query if the WHERE clause of the query matches the column(s) that are leftmost in the index. So if you create a composite index, such as "City, State", then a query such as "WHERE City = 'Houston'" will use the index, but the query "WHERE STATE = 'TX'" will not use the index.

Generally, if a table needs only one index, make it a clustered index. If a table needs more than one index, then you have no choice but to use non-clustered indexes. By following the above recommendations, you will be well on your way to selecting the optimum indexes for your tables.

What to Do Next?
This article has a lot of information, but on the other hand, it has barely touched the surface when it comes to performance tuning and optimization. Reading this article has been your first step. Now its time for you to take the next step, and that is to learn all you can about how SQL Server works internally and the tools described in this article. Remember, SQL Server performance tuning is more of an art than a science, and only through the mastery of the basics, and experience, can you become an expert at SQL Server performance tuning.

Mobile Site | Full Site