- SQL Server Reference Guide
- Introduction
- SQL Server Reference Guide Overview
- Table of Contents
- Microsoft SQL Server Defined
- SQL Server Editions
- SQL Server Access
- Informit Articles and Sample Chapters
- Online Resources
- Microsoft SQL Server Features
- SQL Server Books Online
- Clustering Services
- Data Transformation Services (DTS) Overview
- Replication Services
- Database Mirroring
- Natural Language Processing (NLP)
- Analysis Services
- Microsot SQL Server Reporting Services
- XML Overview
- Notification Services for the DBA
- Full-Text Search
- SQL Server 2005 - Service Broker
- Using SQL Server as a Web Service
- SQL Server Encryption Options Overview
- SQL Server 2008 Overview
- SQL Server 2008 R2 Overview
- SQL Azure
- The Utility Control Point and Data Application Component, Part 1
- The Utility Control Point and Data Application Component, Part 2
- Microsoft SQL Server Administration
- The DBA Survival Guide: The 10 Minute SQL Server Overview
- Preparing (or Tuning) a Windows System for SQL Server, Part 1
- Preparing (or Tuning) a Windows System for SQL Server, Part 2
- Installing SQL Server
- Upgrading SQL Server
- SQL Server 2000 Management Tools
- SQL Server 2005 Management Tools
- SQL Server 2008 Management Tools
- SQL Azure Tools
- Automating Tasks with SQL Server Agent
- Run Operating System Commands in SQL Agent using PowerShell
- Automating Tasks Without SQL Server Agent
- Storage – SQL Server I/O
- Service Packs, Hotfixes and Cumulative Upgrades
- Tracking SQL Server Information with Error and Event Logs
- Change Management
- SQL Server Metadata, Part One
- SQL Server Meta-Data, Part Two
- Monitoring - SQL Server 2005 Dynamic Views and Functions
- Monitoring - Performance Monitor
- Unattended Performance Monitoring for SQL Server
- Monitoring - User-Defined Performance Counters
- Monitoring: SQL Server Activity Monitor
- SQL Server Instances
- DBCC Commands
- SQL Server and Mail
- Database Maintenance Checklist
- The Maintenance Wizard: SQL Server 2000 and Earlier
- The Maintenance Wizard: SQL Server 2005 (SP2) and Later
- The Web Assistant Wizard
- Creating Web Pages from SQL Server
- SQL Server Security
- Securing the SQL Server Platform, Part 1
- Securing the SQL Server Platform, Part 2
- SQL Server Security: Users and other Principals
- SQL Server Security – Roles
- SQL Server Security: Objects (Securables)
- Security: Using the Command Line
- SQL Server Security - Encrypting Connections
- SQL Server Security: Encrypting Data
- SQL Server Security Audit
- High Availability - SQL Server Clustering
- SQL Server Configuration, Part 1
- SQL Server Configuration, Part 2
- Database Configuration Options
- 32- vs 64-bit Computing for SQL Server
- SQL Server and Memory
- Performance Tuning: Introduction to Indexes
- Statistical Indexes
- Backup and Recovery
- Backup and Recovery Examples, Part One
- Backup and Recovery Examples, Part Two: Transferring Databases to Another System (Even Without Backups)
- SQL Profiler - Reverse Engineering An Application
- SQL Trace
- SQL Server Alerts
- Files and Filegroups
- Partitioning
- Full-Text Indexes
- Read-Only Data
- SQL Server Locks
- Monitoring Locking and Deadlocking
- Controlling Locks in SQL Server
- SQL Server Policy-Based Management, Part One
- SQL Server Policy-Based Management, Part Two
- SQL Server Policy-Based Management, Part Three
- Microsoft SQL Server Programming
- An Outline for Development
- Database
- Database Services
- Database Objects: Databases
- Database Objects: Tables
- Database Objects: Table Relationships
- Database Objects: Keys
- Database Objects: Constraints
- Database Objects: Data Types
- Database Objects: Views
- Database Objects: Stored Procedures
- Database Objects: Indexes
- Database Objects: User Defined Functions
- Database Objects: Triggers
- Database Design: Requirements, Entities, and Attributes
- Business Process Model Notation (BPMN) and the Data Professional
- Business Questions for Database Design, Part One
- Business Questions for Database Design, Part Two
- Database Design: Finalizing Requirements and Defining Relationships
- Database Design: Creating an Entity Relationship Diagram
- Database Design: The Logical ERD
- Database Design: Adjusting The Model
- Database Design: Normalizing the Model
- Creating The Physical Model
- Database Design: Changing Attributes to Columns
- Database Design: Creating The Physical Database
- Database Design Example: Curriculum Vitae
- NULLs
- The SQL Server Sample Databases
- The SQL Server Sample Databases: pubs
- The SQL Server Sample Databases: NorthWind
- The SQL Server Sample Databases: AdventureWorks
- The SQL Server Sample Databases: Adventureworks Derivatives
- UniversalDB: The Demo and Testing Database, Part 1
- UniversalDB: The Demo and Testing Database, Part 2
- UniversalDB: The Demo and Testing Database, Part 3
- UniversalDB: The Demo and Testing Database, Part 4
- Getting Started with Transact-SQL
- Transact-SQL: Data Definition Language (DDL) Basics
- Transact-SQL: Limiting Results
- Transact-SQL: More Operators
- Transact-SQL: Ordering and Aggregating Data
- Transact-SQL: Subqueries
- Transact-SQL: Joins
- Transact-SQL: Complex Joins - Building a View with Multiple JOINs
- Transact-SQL: Inserts, Updates, and Deletes
- An Introduction to the CLR in SQL Server 2005
- Design Elements Part 1: Programming Flow Overview, Code Format and Commenting your Code
- Design Elements Part 2: Controlling SQL's Scope
- Design Elements Part 3: Error Handling
- Design Elements Part 4: Variables
- Design Elements Part 5: Where Does The Code Live?
- Design Elements Part 6: Math Operators and Functions
- Design Elements Part 7: Statistical Functions
- Design Elements Part 8: Summarization Statistical Algorithms
- Design Elements Part 9:Representing Data with Statistical Algorithms
- Design Elements Part 10: Interpreting the Data—Regression
- Design Elements Part 11: String Manipulation
- Design Elements Part 12: Loops
- Design Elements Part 13: Recursion
- Design Elements Part 14: Arrays
- Design Elements Part 15: Event-Driven Programming Vs. Scheduled Processes
- Design Elements Part 16: Event-Driven Programming
- Design Elements Part 17: Program Flow
- Forming Queries Part 1: Design
- Forming Queries Part 2: Query Basics
- Forming Queries Part 3: Query Optimization
- Forming Queries Part 4: SET Options
- Forming Queries Part 5: Table Optimization Hints
- Using SQL Server Templates
- Transact-SQL Unit Testing
- Index Tuning Wizard
- Unicode and SQL Server
- SQL Server Development Tools
- The SQL Server Transact-SQL Debugger
- The Transact-SQL Debugger, Part 2
- Basic Troubleshooting for Transact-SQL Code
- An Introduction to Spatial Data in SQL Server 2008
- Performance Tuning
- Performance Tuning SQL Server: Tools and Processes
- Performance Tuning SQL Server: Tools Overview
- Creating a Performance Tuning Audit - Defining Components
- Creating a Performance Tuning Audit - Evaluation Part One
- Creating a Performance Tuning Audit - Evaluation Part Two
- Creating a Performance Tuning Audit - Interpretation
- Creating a Performance Tuning Audit - Developing an Action Plan
- Understanding SQL Server Query Plans
- Performance Tuning: Implementing Indexes
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 1
- Performance Monitoring Tools: Windows 2008 (and Higher) Server Utilities, Part 2
- Performance Monitoring Tools: Windows System Monitor
- Performance Monitoring Tools: Logging with System Monitor
- Performance Monitoring Tools: User Defined Counters
- General Transact-SQL (T-SQL) Performance Tuning, Part 1
- General Transact-SQL (T-SQL) Performance Tuning, Part 2
- General Transact-SQL (T-SQL) Performance Tuning, Part 3
- Performance Monitoring Tools: An Introduction to SQL Profiler
- Performance Tuning: Introduction to Indexes
- Performance Monitoring Tools: SQL Server 2000 Index Tuning Wizard
- Performance Monitoring Tools: SQL Server 2005 Database Tuning Advisor
- Performance Monitoring Tools: SQL Server Management Studio Reports
- Performance Monitoring Tools: SQL Server 2008 Activity Monitor
- The SQL Server 2008 Management Data Warehouse and Data Collector
- Performance Monitoring Tools: Evaluating Wait States with PowerShell and Excel
- Practical Applications
- Choosing the Back End
- The DBA's Toolbox, Part 1
- The DBA's Toolbox, Part 2
- Scripting Solutions for SQL Server
- Building a SQL Server Lab
- Using Graphics Files with SQL Server
- Enterprise Resource Planning
- Customer Relationship Management (CRM)
- Building a Reporting Data Server
- Building a Database Documenter, Part 1
- Building a Database Documenter, Part 2
- Data Management Objects
- Data Management Objects: The Server Object
- Data Management Objects: Server Object Methods
- Data Management Objects: Collections and the Database Object
- Data Management Objects: Database Information
- Data Management Objects: Database Control
- Data Management Objects: Database Maintenance
- Data Management Objects: Logging the Process
- Data Management Objects: Running SQL Statements
- Data Management Objects: Multiple Row Returns
- Data Management Objects: Other Database Objects
- Data Management Objects: Security
- Data Management Objects: Scripting
- Powershell and SQL Server - Overview
- PowerShell and SQL Server - Objects and Providers
- Powershell and SQL Server - A Script Framework
- Powershell and SQL Server - Logging the Process
- Powershell and SQL Server - Reading a Control File
- Powershell and SQL Server - SQL Server Access
- Powershell and SQL Server - Web Pages from a SQL Query
- Powershell and SQL Server - Scrubbing the Event Logs
- SQL Server 2008 PowerShell Provider
- SQL Server I/O: Importing and Exporting Data
- SQL Server I/O: XML in Database Terms
- SQL Server I/O: Creating XML Output
- SQL Server I/O: Reading XML Documents
- SQL Server I/O: Using XML Control Mechanisms
- SQL Server I/O: Creating Hierarchies
- SQL Server I/O: Using HTTP with SQL Server XML
- SQL Server I/O: Using HTTP with SQL Server XML Templates
- SQL Server I/O: Remote Queries
- SQL Server I/O: Working with Text Files
- Using Microsoft SQL Server on Handheld Devices
- Front-Ends 101: Microsoft Access
- Comparing Two SQL Server Databases
- English Query - Part 1
- English Query - Part 2
- English Query - Part 3
- English Query - Part 4
- English Query - Part 5
- RSS Feeds from SQL Server
- Using SQL Server Agent to Monitor Backups
- Reporting Services - Creating a Maintenance Report
- SQL Server Chargeback Strategies, Part 1
- SQL Server Chargeback Strategies, Part 2
- SQL Server Replication Example
- Creating a Master Agent and Alert Server
- The SQL Server Central Management System: Definition
- The SQL Server Central Management System: Base Tables
- The SQL Server Central Management System: Execution of Server Information (Part 1)
- The SQL Server Central Management System: Execution of Server Information (Part 2)
- The SQL Server Central Management System: Collecting Performance Metrics
- The SQL Server Central Management System: Centralizing Agent Jobs, Events and Scripts
- The SQL Server Central Management System: Reporting the Data and Project Summary
- Time Tracking for SQL Server Operations
- Migrating Departmental Data Stores to SQL Server
- Migrating Departmental Data Stores to SQL Server: Model the System
- Migrating Departmental Data Stores to SQL Server: Model the System, Continued
- Migrating Departmental Data Stores to SQL Server: Decide on the Destination
- Migrating Departmental Data Stores to SQL Server: Design the ETL
- Migrating Departmental Data Stores to SQL Server: Design the ETL, Continued
- Migrating Departmental Data Stores to SQL Server: Attach the Front End, Test, and Monitor
- Tracking SQL Server Timed Events, Part 1
- Tracking SQL Server Timed Events, Part 2
- Patterns and Practices for the Data Professional
- Managing Vendor Databases
- Consolidation Options
- Connecting to a SQL Azure Database from Microsoft Access
- SharePoint 2007 and SQL Server, Part One
- SharePoint 2007 and SQL Server, Part Two
- SharePoint 2007 and SQL Server, Part Three
- Querying Multiple Data Sources from a Single Location (Distributed Queries)
- Importing and Exporting Data for SQL Azure
- Working on Distributed Teams
- Professional Development
- Becoming a DBA
- Certification
- DBA Levels
- Becoming a Data Professional
- SQL Server Professional Development Plan, Part 1
- SQL Server Professional Development Plan, Part 2
- SQL Server Professional Development Plan, Part 3
- Evaluating Technical Options
- System Sizing
- Creating a Disaster Recovery Plan
- Anatomy of a Disaster (Response Plan)
- Database Troubleshooting
- Conducting an Effective Code Review
- Developing an Exit Strategy
- Data Retention Strategy
- Keeping Your DBA/Developer Job in Troubled Times
- The SQL Server Runbook
- Creating and Maintaining a SQL Server Configuration History, Part 1
- Creating and Maintaining a SQL Server Configuration History, Part 2
- Creating an Application Profile, Part 1
- Creating an Application Profile, Part 2
- How to Attend a Technical Conference
- Tips for Maximizing Your IT Budget This Year
- The Importance of Blue-Sky Planning
- Application Architecture Assessments
- Transact-SQL Code Reviews, Part One
- Transact-SQL Code Reviews, Part Two
- Cloud Computing (Distributed Computing) Paradigms
- NoSQL for the SQL Server Professional, Part One
- NoSQL for the SQL Server Professional, Part Two
- Object-Role Modeling (ORM) for the Database Professional
- Business Intelligence
- BI Explained
- Developing a Data Dictionary
- BI Security
- Gathering BI Requirements
- Source System Extracts and Transforms
- ETL Mechanisms
- Business Intelligence Landscapes
- Business Intelligence Layouts and the Build or Buy Decision
- A Single Version of the Truth
- The Operational Data Store (ODS)
- Data Marts – Combining and Transforming Data
- Designing Data Elements
- The Enterprise Data Warehouse — Aggregations and the Star Schema
- On-Line Analytical Processing (OLAP)
- Data Mining
- Key Performance Indicators
- BI Presentation - Client Tools
- BI Presentation - Portals
- Implementing ETL - Introduction to SQL Server 2005 Integration Services
- Building a Business Intelligence Solution, Part 1
- Building a Business Intelligence Solution, Part 2
- Building a Business Intelligence Solution, Part 3
- Tips and Troubleshooting
- SQL Server and Microsoft Excel Integration
- Tips for the SQL Server Tools: SQL Server 2000
- Tips for the SQL Server Tools – SQL Server 2005
- Transaction Log Troubles
- SQL Server Connection Problems
- Orphaned Database Users
- Additional Resources
- Tools and Downloads
- Utilities (Free)
- Tool Review (Free): DBDesignerFork
- Aqua Data Studio
- Microsoft SQL Server Best Practices Analyzer
- Utilities (Cost)
- Quest Software's TOAD for SQL Server
- Quest Software's Spotlight on SQL Server
- SQL Server on Microsoft's Virtual PC
- Red Gate SQL Bundle
- Microsoft's Visio for Database Folks
- Quest Capacity Manager
- SQL Server Help
- Visual Studio Team Edition for Database Professionals
- Microsoft Assessment and Planning Solution Accelerator
- Aggregating Server Data from the MAPS Tool
SQL Server is a complex platform for applications, which means that configuring your environment isn't limited to the SQL Server software alone. You have to take all the factors into consideration, such as the hardware each server is running, the network, and even the architecture of the application. In this tutorial, I explain configuration options that are pertinent in architectures found in mainstream applications today. I’ll cover SQL Server versions 2000 through 2008 R2, but not for SQL Azure. SQL Azure starts your environment at the database level, not the Instance level. If you’re not familiar with the idea of a SQL Server Instance, check out this article first.
SQL Server is largely self-tuning. It's normally best to allow SQL Server to dynamically adjust the settings it maintains and not take the reins, but it can be useful to know what each setting does and how it affects the platform. Don't make changes to any server without understanding what the effect will be on your environment. In other cases, it’s important to make changes to environment based on your needs. In both cases, you need to know what the settings do to your server to make the right choice.
Once you understand the settings do and when you should use them, you can adjust the settings for SQL Server using either Transact-SQL commands or by graphically changing them using the graphical management tools. For SQL Server 2000 and lower, that’s Enterprise Manager, and in SQL Server 2005 and higher, it’s SQL Server Management Studio (SSMS). I’ll focus first on the graphical tools, and then explain the commands you can use once you understand what each graphical area does.
In this tutorial I’ll use SSMS, but to access these types of settings graphically in SQL Server 2000 and earlier, just use Enterprise Manager, right click the name of the Instance, and select “Properties” from the menu that appears. In SSMS, connect to the Instance you want to change, right-click the name of that Instance in the Object Explorer pane, normally found on the left-hand side of the SSMS tool. Once the menu appears, select “Properties” from the menu that appears. That will bring you to the “General” tab.
The General tab shows a lot of information about your server, such as how many processors it has and the OS level. (You can get some of this same information with the T-SQL command EXEC xp_msver) In SQL Server 2005 and higher, this is a read-only panel. You’ll notice the data on the right is grayed-out, and you can’t edit it.
In SQL Server 2000, you can set options such as whether the server will auto-start, as well as the SQL Server Agent and the MSDTC service. Depending on how your application is set, you probably want all three; in the case of 3-tier or N-tier architectures, you'll want MSDTC to auto-start. This service provides for Distributed Transactions, something those architectures depend on.
Also in version 2000, the Network Protocol section allows you to tie out the server to the protocols on which it will listen. Order isn't important here, since the server listens to whatever the client sends. Order is important at the client. Network and services functions are handled in the SQL Server Configuration Manager tool in SQL Server 2005 and higher.
The next tab is “Memory.” More than just about any other tuning you can do, the memory settings have the greatest affect on your system. I assume that you've got plenty of RAM on the server; 2GB is just about the lowest I recommend, even for small applications.
The number sections (2005+) and sliders (2000-) on this tab set the lower and upper boundaries that SQL Server will work with. If your server is only running SQL Server, I normally recommend a fixed setting (setting the upper and lower boundaries the same), leaving the OS at least 1 GB of RAM. You might be running the middle tier on this server if you're in a small environment. In that case, ensure that you leave enough RAM for that software to run.
If you do leave a minimum and maximum value for the memory, SQL Server will automatically use as much memory as it needs, and release that memory back to the operating system when the OS needs it or SQL Server does not. The reason I advocate setting a fixed amount on the RAM is so that SQL Server won't have to constantly adjust itself while it's running. It's got enough to do already, without adding work.
You can also set a fixed amount for queries, but it's best to leave this at the default. SQL Server is normally better at managing that. In SQL Server 2005 and higher, you can also change the memory used to create indexes, but once again the default (0, in this case) is most often the correct choice.
On this tab and most that follow, you also see that you can change the settings to reflect "running values." That means that SQL will look at what is in place at this moment, and adjust the sliders to those levels. Once you change the settings, they are the new “configured” values. Some of these need a restart for the new setting to take effect, and in others it doesn’t. Since this behavior changes from release to release, it’s best to read up on any setting you plan to change to find out whether that’s needed or not.
The next tab sets the processor options. The first option allows you to set which processors SQL Server uses.
This is the only Microsoft product that I'm aware of that has this setting, although with other products you can locate their “process” using the Windows Task Manager and change the processors there. I don’t recommend you do that in either place, unless you need a processor or two left out for use by other applications. I’ve also seen this setting altered when only a few of the processors have been licensed for SQL Server.
The Microsoft Windows operating systems use Symmetric Multi-Processing (SMP). This means that all processors in a system are treated as one. Other operating systems are Asymmetric Multi-Processing (AMP), meaning that programs must be coded to run on one or more processors specifically.
Both architectures have advantages. SQL Server claims its heritage from the UNIX world (when Microsoft licensed the engine from Sybase) and so has the ability to be tied to a particular processor.
I've seen shops use three of four processors in a system this way. Unless you've installed the middle-tier on the SQL Server, I don't recommend this. I think that using all the processors is the best way to go, something I've seen proven in experience.
In some cases you’ll see more processors than you physically have in the server, because of “multi-core” or hyper-threaded processors. As of this writing, SQL Server is licensed per physical socket, so you don’t have to pay extra for those “enhanced” processors. As always, this is subject to change, so be sure you check your licensing documentation so that you stay legal.
Another setting you can change here are worker threads, which is the number of threads the system uses for each connection. It's set by default to 255 in early versions of SQL Server, and 0 in later versions, which means the system manages the connections. Changing this setting means that each connection get a thread. After the number you specify, the system starts pooling the connections, which might drive up processor context switches, which can be bad. If you have a constant number of connections, adjust this number a bit higher than the connections. Any higher, and you're wasting resources; any lower, and you're creating too many threads.
If you're running in a 3-tier or N-tier architecture, make sure you average the connections over a long period of time. Connections from these architectures pool and break, so a single measurement, or even a few isn't adequate.
You can also boost the priority of SQL Server on the operating system, which at first might seem like a good thing. If you're using a third-party backup solution, it might be best to leave this alone so that the backup takes priority during the run and gets done faster.
The next option allows you to change from threads to fibers. Switching threads from user to kernel mode can be expensive from an operating system standpoint. Fibers make up threads, and aren't managed by the OS.
Setting this switch allows SQL Server to manage this switch, which is less expensive. But if you do, then you've added workload to SQL Server, which is usually bad. The best thing to do is watch the Performance Counter of Processor:Context Switches. If this number is into the tens of thousands, switch to fibers and see if performance improves. This isn't a necessary exercise, it's still usually best to leave this at the defaults.
In SQL Server 200 and lower, the final area on the Processor tab allows you to set the way that queries will parallelize. I recommend that you use all your processors to do this kind of work. If SQL Server determines that a query plan would benefit from parallelization, give it room to do so. Again, the defaults are normally best here.
You can also set how "deep" SQL Server will look to see if it can parallelize a query. The default of 5 is the right choice for almost every instance. If it has to look deeper than that, you might want to re-factor your query.
In the next tutorial, I'll continue the server settings with the rest of the tabs.
InformIT Articles and Sample Chapters
The article Windows Processes and Threads: Weaving It All Together discusses NT threads in depth.
Books and eBooks
I cover these settings in more depth for SQL Server 2005 in my book Administrator's Guide to SQL Server 2005.
Online Resources
Each setting is explained in more depth in Books Online.