- 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
In a previous article, I explained one of the most powerful constructs in the Transact-SQL (T-SQL) language — the SELECT statement. This most basic of statements is used to retrieve data from tables or views. You can also use it query system variables that will show you things like the name of the server, the time on the system, or you can even use it to perform mathematical or statistical functions on numbers or data. But the most common use for SELECT is to pull data from the database.
As I explained, the simplest form of SELECT is:
SELECT something; GO
A couple of notes here. First, in T-SQL, the SELECT statement doesn't have to be capitalized. I just find that it's easier to read code if the keywords from the language are capitalized. Second, I included a semicolon (;) at the end of the statement — not because it was on a single line, but because it terminates a statement like SELECT. While this isn't required, it's good form, and as of this writing it's been announced that it will be required in the future. Lastly, I included a GO in there — which means do this group (or block or transaction) as a unit. There are times when that actually is required, as I'll explain further.
While the SELECT something works, it only works when you're not looking for data from a table. So this works well:
SELECT 'Buck'; GO
Which returns the word Buck to the results pane. Notice that I put a "tick" character (') around Buck, because I wanted it treated as text. If I wanted to return a number, I leave that off:
SELECT 1; GO
So you can see data types matter when you run a SELECT statement. So far, this isn't terribly useful, although you can use it to find out things like the current date:
SELECT GETDATE(); GO
Where GETDATE() is a system function. But again, you're normally after data in a table, so you add the FROM clause, like I explained in the previous article:
SELECT something FROM somewhere; GO
I explained earlier that the "something" is normally one or more columns, and that the "somewhere" is normally a table or view. And this is where the first part of the limitation of data comes in. Using the Adventureworks sample database, you can return all of the row (also called a tuple or record) and all of the columns (also called attributes) from the People Table like this:
USE Adventureworks; GO SELECT * FROM Person.Contact; GO
This is almost always a bad idea. You rarely need all of the columns and all of the rows in a database, and even if you do, it's a far better practice to list the column names out in the order you want them. In fact, this is the first way that you can limit the data you return from the system. Always find out exactly what the application needs, and then go after only that data. For instance, assume I only want the first and last names and the e-mail addresses from this table. For that I'll just select those columns:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact; GO
So far this is a refresher of what I've already covered. Selecting only certain columns is a way to limit data vertically, which saves resources on the server, the network, the client and so on. Now I want to limit the number of rows that come back — a horizontal limit. One simple way to do that is to tell the system to only bring back a certain number of rows. You can do that with the TOP modifier:
SELECT TOP 100 SELECT FirstName, LastName, EmailAddress FROM Person.Contact; GO
But that isn't in any kind of order, so the system simply pulled back the first 100 rows it found. You could add an ORDER BY statement (more on that later) to bring back the first 100 rows by name or e-mail address, but that isn't a common case either.
What you're really after is a way to compare some value to the data and bring back only those rows that match, don't match, or have some other relationship. The way the SQL language deals with this need is the WHERE modifier. It's similar to asking someone, "Get me all the blue pencils." Here's the format:
SELECT something FROM somewhere WHERE something = somevalue; GO
I'll put this concept into a practical example. Let's say I only want the names of the authors where their last name is "White." Here's the query for that:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName = 'White'; GO
And you get back the records where the last name is White. I'll continue this example by finding out the same information (last name is White) but also if another field "EmailPromotion" is "No" or 0. Here's the query:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName = 'White' AND EmailPromotion = 0; GO
Notice that the column I compared on (EMailPromotion), isn't part of the data I want to show. For now, it's important to understand that the items you compare on don't have to be part of the SELECT statement.
So far I've used only one operator so far, the = sign. This operator means that the item on the right must match the item on the left. There are several other operators, most of them obvious, some of them not. Here's a table that explains a few of them:
Operator |
Meaning |
= |
(Equals) Equal to |
> |
(Greater Than) Greater than |
< |
(Less Than) Less than |
>= |
(Greater Than or Equal To) Greater than or equal to |
<= |
(Less Than or Equal To) Less than or equal to |
<> |
(Not Equal To) Not equal to |
!= |
(Not Equal To) Not equal to (not SQL-92 standard) |
!< |
(Not Less Than) Not less than (not SQL-92 standard) |
!> |
(Not Greater Than) Not greater than (not SQL-92 standard) |
ALL |
TRUE if all of a set of comparisons are TRUE. |
AND |
TRUE if both Boolean expressions are TRUE. |
ANY |
TRUE if any one of a set of comparisons are TRUE. |
BETWEEN |
TRUE if the operand is within a range. |
EXISTS |
TRUE if a subquery contains any rows. |
IN |
TRUE if the operand is equal to one of a list of expressions. |
LIKE |
TRUE if the operand matches a pattern (Text). |
NOT |
Reverses the value of any other Boolean operator. |
OR |
TRUE if either Boolean expression is TRUE. |
This is quite the list — and it's not even all of them! Here's where you can get into "deep weeds" very quickly in using the layering technique on the SQL Statements.
I took quite a bit of time explaining the SELECT and WHERE constructs, but now I'll move a bit quicker with the queries using these operators. I won't cover them all in this lesson, but we will by the end of the series.
It's important to note that some operators don't go with certain types of data. Some numeric operators, for instance, don't work with certain data types (such as DATETIME) in ways that you might expect.
That being said, I'll take a few moments to explain a couple of these operators and show you how they work. I'll start by addressing a shortcoming with the = sign (equality) operator.
With the equality operator, both sides of the condition must match for any rows to return. Many times, however, you want only certain parts of the condition to match. For instance, if you only want to match on the first letter of the condition, you can't use the equality operand. For that, you can use the LIKE operator.
The LIKE operator does just what it says. For instance, this query returns rows where the last name is like "White":
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName LIKE 'White'; GO
Of course, this example is no different than what you can get with the equality operator. The real power with LIKE comes with the wildcard characters that it supports. Wildcards simply take the place of any other character. The most widely used wildcard is the % sign, which takes the place of one or more characters. Here's a query that returns all the last names that start with the letter "B":
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName LIKE 'B%'; GO
The % wildcard works in both directions, meaning that you can set the wildcard for the letters in front of another that you want to query on. This query returns all the names where the last name ends in the letter "e":
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName LIKE '%e'; GO
That ending doesn't have to be a single letter, either; you can use multiple letters at the beginning or end. OK, just to overdo this example, there's one more way to use the % wildcard. To find all the last names that start with the letters "Br" and end with the letter "s", the query would look like this:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName LIKE 'Br%s'; GO
If you wanted the last names that had the letters "ee" somewhere in them:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName LIKE '%ee%'; GO
There are other wildcards, of course, and they work in much the same way. Here's another table to help with those:
Symbol |
Description |
% |
Any string of zero or more characters |
_ |
(underscore) Any single character |
[ ] |
Any single character within the specified range ([a-f]) or set ([abcdef]) |
[^] |
Any single character not within the specified range ([^a-f]) or set ([^abcdef]) |
As you can see, just with the LIKE operator, the complexity and power of the SELECT statement is growing. I'll explain one more layering concept that I'll use in future tutorials.
Going back to that operators chart, you can see that you have a convenient way to negate any of your queries, finding its opposite. That operator, NOT, is used in conjunction with other operators. It negates anything it's in front of. Here's a query that finds all the names where the first two letters of the last name aren't "Wh":
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName NOT LIKE 'Wh%'; GO
If you're just after negating the entire string, by the way, you don't have to bother with NOT. You can just use the inequality symbol, <>. It's sort of a greater-than and less-than symbol all at once. Here's how that looks in a query:
SELECT FirstName, LastName, EmailAddress FROM Person.Contact WHERE LastName <> 'White'; GO
As mentioned, however, this is only for complete inequalities, not wildcard matches.
As you can see, simply layering these simple statements together allows you to create very complicated selection criteria. You should practice a great deal with the AdventureWorks sample database, and explore the sample queries for it found in Books Online. It's one of the most important skills you can have as a database developer.