- 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
- “No plan survives contact with the enemy.” Helmuth von Moltke the Elder
I’ve written here on InformIT in multiple locations about having a plan to help you recover from a disaster. Like many data professionals, I’m a bit of a stickler about planning everything out I think that without a good plan, you’re inviting even more trouble during a catastrophe. I was also in the military, and had the value of plans drilled into me constantly.
Having those plans, and probably more importantly going through a planning process, has saved my backside more times than I can remember. Plans make sure that I thought everything through, that I had spare parts on hand, that I knew who to call about a particular part of the recovery process, and much more. They simply remove most of the uncertainty during the panic that follows a crisis, when it tends to build the most.
When the plan works, of course.
Because they don’t always work. Sometimes the plan doesn’t include one little variable which might be the most important variable. The plan might not be valid for the situation, or more likely, the situation might change and the plan doesn’t. At that point, the plan doesn’t make sense any more.
So does that mean that you shouldn’t plan? No. It doesn’t. It means that if you’re going to put your trust in the plan, it has to work. And the only way you can know that it will work is to try it out. And that’s where the difficulty comes in. You might have a great plan it might cover everything you can think of, but if you don’t take the time to exercise it through a few times, you’re begging for trouble.
Don’t believe me? Think you’ve covered the bases? Allow me to tell you a true story about a team that learned about plans the hard way.
The Environment
I was the IT manager of a small group of about eight professionals. We had a project to deploy several hundred very small networked systems across a large territory to remote offices, and those offices would not have an IT presence. We had to create a single server with mail, office and SQL Server on it. Up to five workstations connected to the network, and a nightly job loaded all of the transactions during the day to a miniframe computer from each office.
The creation and distribution for this network was a thing of beauty. The network engineer on the team figured out how to get the buildings wired with a specific color of network cables for each use. The local hubs and routers had those same colors on the ports. The System Administrator on the team had the small server’s ports coded with the same color of sticker so that plug-in was a snap.
We all created our parts of the server I had the mail administrator set up mail, the system administrator create file and printer shares, and we even imaged the server drives and had the hardware vendor create an automated process that would see the systems configure themselves on site by location name. It created a domain, handled the networking, and even had an image of the workstations to automatically build each one with everything the user needed.
The system would then contact the miniframe, send us an e-mail that everything went well, and set up all of its own maintenance. If a workstation ever had a problem, the user simply pressed a certain key, and the whole thing was rebuilt. Their data was saved on the server, and they continued working less than an hour later.
The team thought of everything. We had tapes and tape drives in each server. The receptionists at each site were taught to change the tapes each morning, and the servers backed up everything onto tape every night. The “recovery disk” was taped on the side, and everything was all set.
The Setup
One morning I announced that we needed to run a test. How confident did the team feel about a “real” disaster? They looked at each other and said “bring it on.”
I had the team “ship” a network (server, router and workstation) to a cubicle in the building. I made them wait a week for the “shipping” to work. I asked accounting if I could borrow someone for a few days for the test, and got the cooperation from that team. I asked for someone who would represent the field, and they got me a lady that had actually worked in a remote office at one point. She was very smart, but had no computer experience. It was perfect.
I asked her to follow the instructions to set up the network, the server and then the workstations. The process the team developed worked like a champ. She had the whole thing up and running in record time, without making a single call to the helpdesk, which was standing by with instructions should they need them.
Once the system was up and running, I asked the “remote office” if she would key in some information for me. I then simulated the end of the day by asking her to put in the tape in the tape drive, and let her get back to her job.
We debriefed, and agreed that this part of the test was a success. I told them that at some point I would simulate a disaster. They agreed, and they went home.
The “Disaster”
After the team went home, I walked over to the server. Keep in mind, this was quite some time back, and Windows Servers were kind of a new thing. In fact, it was Windows NT 4.0, and the latest service packs hadn’t even come out yet. So you could get away with a lot of things that you can’t today, and the recovery tools weren’t nearly as robust.
I erased a critical operating system file, logged off of the server and went home.
The Plan in Meltdown
The next day the team came to work, and set about checking their e-mail and chatting. I sat in my office waiting for the call. The “remote site” came on line and she started working on the terminal.
After an hour or so, the terminal caused the server to take a hit on that file I erased, and bluescreened. She came to my office and said “there’s something weird happening on the server.” I nodded. “Should I call someone?” I said, “I don’t know. Did they tell you to call someone?” She shook her head. I said, “what do you think you should do?” She said “I’ll wait and see if it fixes itself.” I said “OK”. It was about 10:00 by this time.
After about a half hour, she came back to my office. “It’s still not working. I think I should call someone.” I said “OK”. She asked who she should call, and I asked her who they told her to call. She said she wasn’t sure the helpdesk maybe? I told her that I thought that might work. It’s now lunchtime.
The helpdesk person didn’t know we were running a test. They dispatched a local IT troop to the cubicle, and when he got there he asked what was up. She stated she was working on a test of some kind, so the tech left.
When the team came back from lunch, they wondered aloud how the performance on the system might be going. I stayed silent. They decided to call and ask how things were going, so I took a seat nearby to hear the conversation. It was now afternoon. Chaos ensued.
After yelling for the team to join them, they glared at me when she told them she had asked me about this at 10:00. I asked them, “Did you tell her to call me? Did you tell her to call anyone?” They looked down at their feet. I said, “well, we’ve been down a day. That’s about 5,000 dollars worth of billing information lost so far.”
I said “You better get started fixing this thing.”
After trying to guide the remote worker through understanding what was going on (they couldn’t see the screen, she couldn’t describe it well) and asking dozens of questions, they realized that the system was down hard. By then it was quitting time, and I told her to go home. They protested but I said, “Do you think they will really stay in the office to help you with this problem in the field?” So they had to wait another day. So far: almost 24 hours of data time lost and they still didn’t realize how bad it was.
The next day she came to work, and they were ready. They asked her to put in the tape, and put in the recovery disk. They tried to get the system up to where they could run the tape restore. But then they ran into a problem the rescue disk (which at the time only tried to restore a few system files) was Windows NT RTM, and the system had SP2 applied as part of the build process. So now the hard drive (with the data she keyed in the first day) was totally trashed.
That’s when I broke the really bad news to them. I told them I trashed the drive before the first backup had been taken. Even if they managed to get the recovery disk in place, the restore would have had nothing on it.
The recovery
Finally, after three full calendar days, they “shipped” a new server to her from the factory. She had to do the entire installation again. I even made them wait a day to let the “shipping” happen. Then I called a meeting.
Believe me, the confidence level was not high. People realized they had put their faith in a plan that had not been tested. But I reminded them it was a test environment and that this was the time to make the needed changes.
What did they do based on what we learned. They had a second server ready and standing by on a shelf at HQ. The system had the same information, process, tape drive and everything else ready to go.
At the first sign of trouble (we practiced again) they shipped the server after they configured the name of the domain. They sent a recovery disk (with the right files) along as well. If the problem turned out not to need the server, they simply shipped it back.
Each site got a training video about the tape backups and how to check them. The server was configured to sent out a “distress call” based on a periodic ping from HQ. Health monitoring was put into place. Each server got a Windows NT slipstreamed installation set of CD’s (no DVD’s back then!) taped to the side, and stickers were placed on the front, back and sides with the helpdesk number and the code to use to indicate the type of problem this was. We also invested in a bare-metal recovery software package when one came out for NT.
We had to use the new process more than once and we learned more each time. That’s the key learning from mistakes, and realizing that you don’t have a disaster plan you have a disaster recovery plan.
InformIT Articles and Sample Chapters
Rate Your "Relationshp" with Your Disaster Recovery Plan is a great article on putting your eggs in one basket...
Books and eBooks
Disaster Recovery Planning: Preparing for the Unthinkable, 3rd Edition should be required reading for any administrator.
A more recent option is Learning from Catastrophes: Strategies for Reaction and Response by Howard Kunreuther and Michael Useem.