- 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
There are multiple places where you can write code against a SQL Server system, depending on the language you are using. In this overview, I’ll explain a few of the options you have, and where you might choose to use each one.
The data layer of programming is one which has the largest variety of people working with it. At one end of the spectrum you have the developer who normally uses an “application” programming language, like Java, C#, C++, Visual Basic.NET or even ASP.NET. This type of developer probably writes code that users will interact with through some sort of User Interface (UI). Sometimes these interfaces are graphical, and sometimes they are command-line based or receive their input from another program or device. If you’re developing in that way, you probably already have your environment and tools picked out. Perhaps it’s even chosen for you.
Developers at this end of the spectrum often write database code that is embedded within other programming constructs. They will create a connection object, and then a command, table or database object to work with. If it’s a command-type object, they set the Transact-SQL statements as a variable (most of the time) and then pass it on to the command object, which executes the command string.
They also might use a “middle tier” program, one that does not have a User Interface but takes inputs from a requesting program and then farms that back out to the database system or systems. This is common in many shops as well, and has a lot of advantages.
At the other end of the spectrum is the “DBA” developer, who knows not only how to write Transact-SQL code but also manages the system, taking care of security, backups and so on. They don’t often live within an application programming suite like Visual Studio, but are more comfortable with the tools that come with SQL Server.
And then there are the developers that live all along that spectrum — perhaps they aren’t a “pure” developer, or perhaps they do more than just manage the database platform. In any case, the coding I’m talking about in this article deals specifically with SQL Server, so the environment needs to be able to handle that environment and the Transact-SQL language with as much dexterity as it does the application-type environment and languages. The tools for that environment are more limited, so I’ll call out the ones I’m familiar with so that you can decide when and where to use each.
Even if you are a “pure” application developer, you want to be familiar with these tools. The tools I’ll describe will be better suited to working with the SQL Server database platform than an application programming environment that is designed for a particular language, simply because these tools are designed specifically for the database server.
I need to start out by defining a few terms and processes. As I have mentioned before, I’m a fan of the Microsoft Solutions Framework (MSF), so if you don’t have a defined process in your shop or yours isn’t working like you want, make sure you check it out. I have links at the bottom of this article on that. The MSF processes suggest the “Agile” approach to software development, so the terms you’ll hear me refer to are there.
Another term I’ll use is “Integrated Development Environment” or IDE, to refer to the entire graphical suite of tools for a given solution that assist you in code development, alteration and deployment out to your development, testing and production servers. For that reason, I won’t mention simple tools like VI, notepad and so on. While those let you type code, they don’t have syntax checking and highlighting, project integration and so on.
I’m also not including the Entity Relationship Modeling tools for that reason. While most all of the options should have this capability, this capability alone isn’t enough to write complicated stored procedures and work with User Defined Types (UDTs) that you’ll need to create with an “true” IDE. But, wherever another tool is deficient in this area (such as SQL Server Management Studio), I do recommend you add this to your toolbox if you design a lot of new databases or make complicated changes to older ones.
I will not include any mention of tools from one vendor that claim to work against another platform. I’ve found that these are almost useless, and the vendors only put limited functionality in the tools so that they can make the claim. I find that dishonest and a waste of time.
Third-party Tools
I’ll start with a brief description of a few third-party tools that you can use to code a database project, but to be honest I’ve only used a few of them, and I don’t use them any longer. That isn’t because they aren’t useful, but because of the primary reason to pay extra for something you already have anyway — let me explain that.
The primary reason to use a third-party tool to develop SQL Server code is when you have a multi-platform environment. In other words, if you’re using SQL Server, Oracle and DB2 in your organization, you might want to consider a tool which can “talk” to all of them. Even then, these tools don’t cover the platforms with the same level of detail and integration as the vendor’s tools.
The first tool I’m familiar with that will allow you to code a SQL Server project is called TOAD, from Quest Software. I’ve described it in a full article some time ago, so I’ll point you to that for the particulars. The upshot is that there is a free version and a pay-for version. To get any real project features (such as a debugger) you need the pay-for version. TOAD does have a module for Oracle and SQL Server, as well as DB2 and MySQL.
If you’re using the Revelation OpenInsight Embedded Engine (something found in many government projects), then you might want to check out the OpenInsight product. This environment presents the coding process in a series of steps, and also works with various database back-ends, including SQL Server. Once again, I haven’t found it to be as rich for developing SQL Server applications as the offerings from Microsoft.
WinSQL, from IndusSoft, does have some pretty impressive capabilities for developing against multiple systems, and it isn’t on the far end of expensive. You can check here for a full feature list of what each edition offers, but I don’t recommend anything less that the Professional edition for the serious developer. It also has probably the highest level of support for the most databases I’ve seen.
PowerSQL by Embarcadero has a great Project system, and is also multi-platform. You can check out that here. I’ve found it a bit more useful against Oracle than SQL Server, but it works well for both. It is also part of a suite of products that work together well not only for developing database code, but modeling and managing the systems as well. DBArtisan, another one of their products, has always been one of my favorite multi-platform monitoring and managing tools.
A surprising (or maybe not) no-show here is Eclipse, the open-source IDE that most IBM shops use. I find it to be a great platform, although it is pretty “do-it-yourself,” but as of right now I don’t see many folks using it with SQL Server. There are only a couple of plug-ins for it that I’ve seen, and most of those are for Java-to-ODBC connectivity and nothing more. But I keep checking back, because I think the potential is there for the best shot at integration.
So if you’re developing a great many database projects on multiple platforms, make sure you watch the demos for each of these products on their websites. Be prepared to do a bit of manual wiring up between your source-control system and these suites, but don’t let that deter you. Also plan to spend a bit of time learning each platform. Just because they are not part of a particular vendor’s offerings doesn’t mean they will be easier to learn and use.
Visual Studio Team Edition for the Database Professional
During the beta of this product I reviewed it, and since then it has grown up quite a bit. I’ll shorten the ridiculously long name to VSDB so that I don’t have to keep typing it here — and you might also have heard of it by its project code name of “Data Dude.”
As part of the Visual Studio Team Suite, this tool integrates very well in a purely Microsoft only shop. As the name implies, it will interoperate with Team Services on multiple levels, and has one of the best code-testing and modeling sections of all the tools I’m mentioning in this article. It also has the ability to generate load against a SQL Server database, and maintain versions of schema objects, along with comparisons of objects in another environment (such as production or testing) with the schema of the objects you have in your development environment.
The part I like best about this tool is that you can develop a complete database project without being connected to any database system at all. It also has a great refactoring capability and can track an object name change through the entire project.
The thing I like least about VSDB is the licensing and price — it’s a really steep climb for small companies. Of course, most small companies aren’t doing the kind of work this product is designed for, so perhaps it’s a wash anyway. You can buy VSDB as a stand-alone edition, but it really needs the whole organization to work within Visual Studio Team Edition to show its true value. However, if you do buy the “Enterprise Architect” edition you get this as part of the suite, so large development shops that focus on Microsoft technologies probably benefit the most from this edition.
SQL Server Management Studio
For some DBAs, the fact that I include SQL Server Management Studio (SSMS) as a development tool seems obvious. Application developers, however, often dismiss SSMs as a management tool. In fact, SSMS is built on Visual Studio, although it has been significantly changed to have more management features than you normally see in a development project.
But SSMS in SQL Server 2008 deserves a second look. A great many new features have been added that allow it to function more as a true development IDE, such as a new debugger, Intellisense (code completion), collapsible code blocks (for SELECT and BEGIN/END statements) to name just a few. Another very useful feature in SSMS for SQL Server 2008 is that you can run multiple queries against a group of servers by right-clicking a group name and selecting “New Query” from the menu that appears.
SSMS also has a fully integrated graphical Query Plan viewer, and you can import and export the plans. There’s a full query designer, you can trace the query in SQL Profiler and the Database Tuning Advisor, and it has the ability to create database Projects, although they are quite limited. You can check code in and out of the Visual Source Safe (VSS) code-control system, but that’s about it — most of the time I just take the project files and place those over whatever source code control system I’m using.
I have covered SSMS here and here, but in a more general way. In future tutorials I’ll zoom in on some of these development features, but even if your shop is still on SQL Server 2000 or 2005, you should definitely buy and install the 2008 developer edition (it’s only 50$ US) for your development efforts. Then you can slowly add the new version to the mix as you test features, but you gain the immediate advantage of being able to be more productive as you develop.
InformIT Articles and Sample Chapters
Not everyone is enthralled with Agile development — check out Agile Development: Weed or Wildflower? to find out more.
Books and eBooks
If you’re a Java developer, you probably already know about Eclipse, but just in case, The Java Developer's Guide to Eclipse, 2nd Edition is a great book on the subject.
Online Resources
The official Microsoft Solutions Framework whitepapers are here.
More information on the Agile software development process using MSF is here.