You are previewing Microsoft® SQL Server® 2008 Internals.
O'Reilly logo
Microsoft® SQL Server® 2008 Internals

Book Description

Delve inside the core SQL Server engine—and put that knowledge to work—with guidance from a team of well-known internals experts. Whether database developer, architect, or administrator, you’ll gain the deep knowledge you need to exploit key architectural changes—and capture the product’s full potential. Discover how SQL Server works behind the scenes, including:

  • What happens internally when SQL Server builds, expands, shrinks, and moves databases

  • How to use event tracking—from triggers to the Extended Events Engine

  • Why the right indexes can drastically reduce your query execution time

  • How to transcend normal row-size limits with new storage capabilities

  • How the Query Optimizer operates

  • Multiple techniques for troubleshooting problematic query plans

  • When to force SQL Server to reuse a cached query plan—or create a new one

  • What SQL Server checks internally when running DBCC

  • How to choose among five isolation levels and two concurrency models when working with multiple concurrent users

  • Table of Contents

    1. Microsoft® SQL Server® 2008 Internals
    2. Foreword
    3. Introduction
      1. Who This Book Is For
      2. What This Book Is About
      3. Companion Content
      4. System Requirements
      5. Support for This Book
        1. Questions and Comments
      6. Acknowledgments
        1. Paul Randal
        2. Kimberly Tripp
        3. Conor Cunningham
        4. Adam Machanic
    4. 1. SQL Server 2008 Architecture and Configuration
      1. SQL Server Editions
      2. SQL Server Metadata
        1. Compatibility Views
        2. Catalog Views
        3. Other Metadata
          1. Information Schema Views
          2. System Functions
          3. System Stored Procedures
          4. Metadata Wrap-Up
      3. Components of the SQL Server Engine
        1. Observing Engine Behavior
        2. Protocols
          1. Tabular Data Stream Endpoints
        3. The Relational Engine
          1. The Command Parser
          2. The Query Optimizer
          3. The Query Executor
        4. The Storage Engine
          1. Access Methods
            1. Row and Index Operations
            2. Page Allocation Operations
            3. Versioning Operations
          2. Transaction Services
            1. Locking Operations
          3. Other Operations
      4. The SQLOS
        1. NUMA Architecture
      5. The Scheduler
        1. SQL Server Workers
          1. SQL Server Schedulers
          2. SQL Server Tasks
          3. Threads vs. Fibers
          4. NUMA and Schedulers
          5. Dynamic Affinity
        2. Binding Schedulers to CPUs
          1. Observing Scheduler Internals
        3. The Dedicated Administrator Connection (DAC)
      6. Memory
        1. The Buffer Pool and the Data Cache
        2. Access to In-Memory Data Pages
        3. Managing Pages in the Data Cache
        4. The Free Buffer List and the Lazywriter
        5. Checkpoints
        6. Managing Memory in Other Caches
          1. The Memory Broker
        7. Sizing Memory
        8. Sizing the Buffer Pool
          1. Observing Memory Internals
          2. NUMA and Memory
          3. Read-Ahead
      7. SQL Server Resource Governor
        1. Resource Governor Overview
          1. Enabling the Resource Governor
          2. Classifier Function
          3. Workload Groups
          4. Resource Pools
          5. Pool Sizing
          6. Example
        2. Resource Governor Controls
        3. Resource Governor Metadata
      8. SQL Server 2008 Configuration
        1. Using SQL Server Configuration Manager
        2. Configuring Network Protocols
        3. Default Network Configuration
        4. Managing Services
          1. SQL Server Browser
      9. SQL Server System Configuration
        1. Operating System Configuration
          1. Task Management
          2. System Paging File Location
          3. Nonessential Services
          4. Connectivity
          5. Firewall Setting
        2. Trace Flags
      10. SQL Server Configuration Settings
        1. Memory Options
          1. Min Server Memory and Max Server Memory
          2. Set Working Set Size
          3. AWE Enabled
          4. User Connections
        2. Scheduling Options
          1. Affinity Mask and Affinity64 Mask
          2. Lightweight Pooling
          3. Priority Boost
          4. Max Worker Threads
        3. Disk I/O Options
          1. Recovery Interval
          2. Affinity I/O Mask and Affinity64 I/O Mask
          3. Backup Compression Default
          4. Filestream Access Level
        4. Query Processing Options
          1. Min Memory Per Query
          2. Query Wait
          3. Blocked Process Threshold
          4. Index Create Memory
          5. Query Governor Cost Limit
          6. Max Degree Of Parallelism and Cost Threshold For Parallelism
        5. The Default Trace
      11. Final Words
    5. 2. Change Tracking, Tracing, and Extended Events
      1. The Basics: Triggers and Event Notifications
        1. Run-Time Trigger Behavior
      2. Change Tracking
        1. Change Tracking Configuration
          1. Database-Level Configuration
          2. Commit Table
          3. Internal Cleanup Task
          4. Table-Level Configuration
          5. Internal Change Table
          6. Change Tracking Hidden Columns
        2. Change Tracking Run-Time Behavior
          1. Query Processing and DML Operations
          2. Column Tracking
          3. CHANGETABLE Function
      3. Tracing and Profiling
        1. SQL Trace Architecture and Terminology
          1. Internal Trace Components
          2. Trace I/O Providers
        2. Security and Permissions
          1. ALTER TRACE Permission
          2. Protecting Sensitive Event Data
        3. Getting Started: Profiler
          1. Profiler Basics
          2. Saving and Replaying Traces
        4. Server-Side Tracing and Collection
          1. Scripting Server-Side Traces
          2. Querying Server-Side Trace Metadata
            1. fn_trace_geteventinfo
            2. sys.trace_events and sys.trace_columns
            3. fn_trace_getfilterinfo
          3. Retrieving Data from Server-Side Traces
          4. Stopping and Closing Traces
          5. Investigating the Rowset Provider
      4. Extended Events
        1. Components of the XE Infrastructure
          1. Packages
          2. Events
          3. Types and Maps
          4. Predicates
          5. Actions
          6. Targets
        2. Event Sessions
          1. Session-Scoped Catalog Metadata
          2. Session-Scoped Configuration Options
          3. Lifecycle of an Event
        3. Extended Events DDL and Querying
          1. Creating an Event Session
          2. Querying Event Data
          3. Stopping and Removing the Event Session
      5. Summary
    6. 3. Databases and Database Files
      1. System Databases
        1. master
        2. model
        3. tempdb
        4. The Resource Database
        5. msdb
      2. Sample Databases
        1. AdventureWorks
        2. pubs
        3. Northwind
      3. Database Files
      4. Creating a Database
        1. A CREATE DATABASE Example
      5. Expanding or Shrinking a Database
        1. Automatic File Expansion
        2. Manual File Expansion
        3. Fast File Initialization
        4. Automatic Shrinkage
        5. Manual Shrinkage
          1. DBCC SHRINKFILE
          2. DBCC SHRINKDATABASE
      6. Using Database Filegroups
        1. The Default Filegroup
        2. A FILEGROUP CREATION Example
        3. Filestream Filegroups
      7. Altering a Database
        1. ALTER DATABASE Examples
      8. Databases Under the Hood
        1. Space Allocation
      9. Setting Database Options
        1. State Options
          1. SINGLE_USER | RESTRICTED_USER | MULTI_USER
          2. OFFLINE | ONLINE | EMERGENCY
          3. READ_ONLY | READ_WRITE
          4. Termination Options
        2. Cursor Options
        3. Auto Options
        4. SQL Options
        5. Database Recovery Options
        6. Other Database Options
      10. Database Snapshots
        1. Creating a Database Snapshot
        2. Space Used by Database Snapshots
        3. Managing Your Snapshots
      11. The tempdb Database
        1. Objects in tempdb
          1. User Objects
          2. Internal Objects
          3. Version Store
        2. Optimizations in tempdb
          1. Logging Optimizations
          2. Allocation and Caching Optimizations
        3. Best Practices
        4. tempdb Space Monitoring
      12. Database Security
        1. Database Access
        2. Managing Database Security
        3. Databases vs. Schemas
        4. Principals and Schemas
        5. Default Schemas
      13. Moving or Copying a Database
        1. Detaching and Reattaching a Database
        2. Backing Up and Restoring a Database
        3. Moving System Databases
        4. Moving the master Database
      14. Compatibility Levels
      15. Summary
    7. 4. Logging and Recovery
      1. Transaction Log Basics
        1. Phases of Recovery
          1. Page LSNs and Recovery
        2. Reading the Log
      2. Changes in Log Size
        1. Virtual Log Files
        2. Observing Virtual Log Files
          1. Multiple Log Files
        3. Automatic Truncation of Virtual Log Files
        4. Maintaining a Recoverable Log
        5. Automatic Shrinking of the Log
        6. Log File Size
      3. Backing Up and Restoring a Database
        1. Types of Backups
        2. Recovery Models
          1. FULL Recovery Model
          2. BULK_LOGGED Recovery Model
          3. SIMPLE Recovery Model
          4. Compatibility with Database Options
        3. Choosing a Backup Type
        4. Restoring a Database
          1. Backing Up and Restoring Files and Filegroups
          2. Partial Backups
          3. Page Restore
          4. Partial Restore
          5. Restoring with Standby
      4. Summary
    8. 5. Tables
      1. Creating Tables
        1. Naming Tables and Columns
        2. Reserved Keywords
        3. Delimited Identifiers
        4. Naming Conventions
        5. Data Types
          1. Choosing a Data Type
          2. Numeric Data Types
          3. Date and Time Data Types
          4. Character Data Types
          5. Character Data Collation
            1. Determining Which Collation to Use
            2. Available Collations
            3. Windows Collations
              1. The Anatomy of a Collation Name
              2. Different Versions of the Same Collation
              3. The Single-Byte Character Types
              4. Sort Order
              5. Character Ranges and Collations
              6. Binary Collations
            4. SQL Server Collations
              1. Sort Orders
              2. Tertiary Collations
            5. Collations Defined During SQL Server Setup
              1. Running the Installation Wizard
            6. Performance Considerations
              1. A Trap with SQL Server Collations
          6. Special Data Types
            1. Binary Data Types
            2. bit Data Type
            3. LOB Data Types
            4. cursor Data Type
            5. rowversion Data Type
            6. sql_variant Data Type
            7. Spatial Data Type
            8. table Data Type
            9. xml Data Type
            10. uniqueidentifier Data Type
        6. Much Ado About NULL
      2. User-Defined Data Types
      3. IDENTITY Property
      4. Internal Storage
        1. The sys.indexes Catalog View
        2. Data Storage Metadata
          1. Querying the Catalog Views
        3. Data Pages
          1. Page Header
          2. Data Rows for In-Row Data
          3. Row Offset Array
        4. Examining Data Pages
        5. The Structure of Data Rows
        6. Finding a Physical Page
        7. Storage of Fixed-Length Rows
        8. Storage of Variable-Length Rows
          1. NULLS and Variable-Length Columns
        9. Storage of Date and Time Data
        10. Storage of sql_variant Data
      5. Constraints
        1. Constraint Names and Catalog View Information
        2. Constraint Failures in Transactions and Multiple-Row Data Modifications
          1. The Order of Integrity Checks
      6. Altering a Table
        1. Changing a Data Type
        2. Adding a New Column
        3. Adding, Dropping, Disabling, or Enabling a Constraint
        4. Dropping a Column
        5. Enabling or Disabling a Trigger
        6. Internals of Altering Tables
      7. Heap Modification Internals
        1. Allocation Structures
        2. Inserting Rows
        3. Deleting Rows
          1. Deleting Rows from a Heap
          2. Reclaiming Pages
        4. Updating Rows
          1. Moving Rows
          2. Managing Forward Pointers
          3. Updating in Place
          4. Updating Not in Place
      8. Summary
    9. 6. Indexes: Internals and Management
      1. Overview
        1. SQL Server Index B-trees
      2. Tools for Analyzing Indexes
        1. Using the dm_db_index_physical_stats DMV
        2. Using DBCC IND
      3. Understanding Index Structures
        1. The Dependency on the Clustering Key
        2. Nonclustered Indexes
        3. Constraints and Indexes
      4. Index Creation Options
        1. IGNORE_DUP_KEY
        2. STATISTICS_NORECOMPUTE
        3. MAXDOP
        4. Index Placement
        5. Constraints and Indexes
      5. Physical Index Structures
        1. Index Row Formats
        2. Clustered Index Structures
          1. Clustered Index Rows with a Uniquifier
        3. The Non-Leaf Level(s) of a Clustered Index
        4. Analyzing a Clustered Index Structure
        5. Nonclustered Index Structures
          1. Nonclustered Index Rows on a Heap
          2. Nonclustered Index Rows on a Clustered Table
          3. Nonunique Nonclustered Index Rows
          4. Nonclustered Index Rows with Included Columns (Using INCLUDE)
          5. Nonclustered Index Rows with Filters (Filtered Indexes)
      6. Special Index Structures
        1. Indexes on Computed Columns and Indexed Views
          1. Prerequisites
          2. SET Options
          3. Permissible Functions
          4. Schema Binding
          5. Indexes on Computed Columns
            1. Using the COLUMNPROPERTY Function
          6. Implementation of a Computed Column
            1. Persisted Columns
          7. Indexed Views
          8. Additional Requirements
          9. Creating an Indexed View
          10. Using an Indexed View
        2. Full-Text Indexes
        3. Spatial Indexes
        4. XML Indexes
      7. Data Modification Internals
        1. Inserting Rows
        2. Splitting Pages
          1. Splitting the Root Page of an Index
          2. Splitting an Intermediate Index Page
          3. Splitting a Leaf-Level Page
        3. Deleting Rows
          1. Deleting Rows from a Heap
          2. Deleting Rows from a B-tree
          3. Deleting Rows in the Non-Leaf Levels of an Index
          4. Reclaiming Pages
        4. Updating Rows
          1. Moving Rows
          2. Managing Forwarding Pointers
          3. Updating in Place
          4. Updating Not in Place
        5. Table-Level vs. Index-Level Data Modification
        6. Logging
        7. Locking
        8. Fragmentation
      8. Managing Index Structures
        1. Dropping Indexes
        2. ALTER INDEX
          1. Rebuilding an Index
          2. Disabling an Index
          3. Changing Index Options
            1. FILLFACTOR and PAD_INDEX
            2. DROP_EXISTING
            3. SORT_IN_TEMPDB
          4. Reorganizing an Index
        3. Detecting Fragmentation
        4. Removing Fragmentation
        5. Rebuilding an Index
          1. Online Index Building
      9. Summary
    10. 7. Special Storage
      1. Large Object Storage
        1. Restricted-Length Large Object Data (Row-Overflow Data)
        2. Unrestricted-Length Large Object Data
          1. LOB Data Stored in the Data Row
        3. Storage of MAX-Length Data
          1. Appending Data into a LOB Column
      2. Filestream Data
        1. Enabling Filestream Data for SQL Server
        2. Creating a Filestream-Enabled Database
        3. Creating a Table to Hold Filestream Data
        4. Manipulating Filestream Data
          1. Inserting Filestream Data
          2. Updating Filestream Data
          3. Deleting Filestream Data
          4. Filestream Data and Transactions
          5. Logging Filestream Changes
          6. Garbage Collection for Filestream Data
        5. Metadata for Filestream Data
        6. Performance Considerations for Filestream Data
      3. Sparse Columns
        1. Management of Sparse Columns
          1. Table Creation
          2. Altering a Table
        2. Column Sets and Sparse Column Manipulation
        3. Physical Storage
        4. Metadata
        5. Storage Savings with Sparse Columns
      4. Data Compression
        1. Vardecimal
        2. Row Compression
          1. Enabling Row Compression
          2. New Row Format
            1. The CD Region
            2. The Short Data Region
            3. The Long Data Region
            4. Special Information
        3. Page Compression
          1. Column Prefix Compression
          2. Dictionary Compression
          3. Physical Storage
            1. Header
              1. PageModCount
            2. Offsets
            3. Anchor Record
            4. Dictionary
          4. Page Compression Analysis
          5. Rebuilding the CI Record
            1. Compression of B-tree Pages
            2. Compression of Heap Pages
          6. Compression Metadata
          7. Performance Issues
            1. Compression and Logging
            2. Compression and the Version Store
          8. Backup Compression
      5. Table and Index Partitioning
        1. Partition Functions and Partition Schemes
        2. Metadata for Partitioning
        3. The Sliding Window Benefits of Partitioning
      6. Summary
    11. 8. The Query Optimizer
      1. Overview
        1. Tree Format
      2. What Is Optimization?
      3. How the Query Optimizer Explores Query Plans
        1. Rules
        2. Properties
        3. Storage of Alternatives—The "Memo"
        4. Operators
          1. Compute Scalar—Project
          2. Compute Sequence—Sequence Project
          3. Semi-Join
          4. Apply
          5. Spools
          6. Exchange
      4. Optimizer Architecture
        1. Before Optimization
        2. Simplification
        3. Trivial Plan/Auto-Parameterization
        4. Limitations
        5. The Memo—Exploring Multiple Plans Efficiently
          1. Convert to Executable Plan
      5. Statistics, Cardinality Estimation, and Costing
        1. Statistics Design
        2. Density/Frequency Information
        3. Filtered Statistics
        4. String Statistics
        5. Cardinality Estimation Details
        6. Limitations
        7. Costing
      6. Index Selection
        1. Filtered Indexes
        2. Indexed Views
      7. Partitioned Tables
        1. Partition-Aligned Index Views
      8. Data Warehousing
      9. Updates
        1. Halloween Protection
        2. Split/Sort/Collapse
        3. Merge
        4. Wide Update Plans
          1. Non-Updating Updates
        5. Sparse Column Updates
        6. Partitioned Updates
        7. Locking
          1. Partition-Level Lock Escalation
      10. Distributed Query
      11. Extended Indexes
        1. Full-Text Indexes
        2. XML Indexes
        3. Spatial Indexes
      12. Plan Hinting
        1. Debugging Plan Issues
        2. {HASH | ORDER} GROUP
        3. {MERGE | HASH | CONCAT } UNION
        4. FORCE ORDER, {LOOP | MERGE | HASH } JOIN
        5. INDEX=<indexname> | <indexid>
        6. FORCESEEK
        7. FAST <number_rows>
        8. MAXDOP <N>
        9. OPTIMIZE FOR
        10. PARAMETERIZATION {SIMPLE | FORCED}
        11. NOEXPAND
        12. USE PLAN
      13. Summary
    12. 9. Plan Caching and Recompilation
      1. The Plan Cache
        1. Plan Cache Metadata
        2. Clearing Plan Cache
      2. Caching Mechanisms
        1. Adhoc Query Caching
        2. Optimizing for Adhoc Workloads
          1. Controlling the Optimize for Ad Hoc Workloads setting
          2. The Compiled Plan Stub
        3. Simple Parameterization
          1. Forced Parameterization
          2. Drawbacks of Simple Parameterization
        4. Prepared Queries
          1. The sp_executesql Procedure
          2. The Prepare and Execute Method
          3. Caching Prepared Queries
        5. Compiled Objects
          1. Stored Procedures
          2. Functions
        6. Causes of Recompilation
          1. Correctness-Based Recompiles
          2. Optimality-Based Recompiles
            1. Updated Statistics
            2. Stale Statistics
            3. Modification Counters
            4. Tracking Changes to Tables and Indexed Views Using colmodctr Values
          3. Skipping the Recompilation Step
          4. Multiple Recompilations
          5. Removing Plans from Cache
      3. Plan Cache Internals
        1. Cache Stores
        2. Compiled Plans
        3. Execution Contexts
        4. Plan Cache Metadata
        5. Handles
        6. sys.dm_exec_sql_text
        7. sys.dm_exec_query_plan
        8. sys.dm_exec_text_query_plan
        9. sys.dm_exec_cached_plans
        10. sys.dm_exec_cached_plan_dependent_objects
        11. sys.dm_exec_requests
        12. sys.dm_exec_query_stats
        13. Cache Size Management
          1. Local Memory Pressure
          2. Global Memory Pressure
        14. Costing of Cache Entries
      4. Objects in Plan Cache: The Big Picture
      5. Multiple Plans in Cache
      6. When to Use Stored Procedures and Other Caching Mechanisms
      7. Troubleshooting Plan Cache Issues
        1. Wait Statistics Indicating Plan Cache Problems
        2. Other Caching Issues
        3. Handling Problems with Compilation and Recompilation
        4. Plan Guides and Optimization Hints
          1. Optimization Hints
            1. RECOMPILE
            2. OPTIMIZE FOR
            3. KEEP PLAN
            4. KEEPFIXED PLAN
            5. PARAMETERIZATION
            6. USE PLAN
          2. Purpose of Plan Guides
          3. Types of Plan Guides
            1. Object Plan Guides
            2. SQL Plan Guides
            3. Template Plan Guides
          4. Managing Plan Guides
          5. Plan Guide Considerations
          6. Plan Guide Validation
          7. Freezing a Plan from Plan Cache
      8. Summary
    13. 10. Transactions and Concurrency
      1. Concurrency Models
        1. Pessimistic Concurrency
        2. Optimistic Concurrency
      2. Transaction Processing
        1. ACID Properties
          1. Atomicity
          2. Consistency
          3. Isolation
          4. Durability
        2. Transaction Dependencies
          1. Lost Updates
          2. Dirty Reads
          3. Nonrepeatable Reads
          4. Phantoms
        3. Isolation Levels
          1. Read Uncommitted
          2. Read Committed
          3. Repeatable Read
          4. Snapshot
          5. Serializable
      3. Locking
        1. Locking Basics
        2. Spinlocks
        3. Lock Types for User Data
        4. Lock Modes
          1. Shared Locks
          2. Exclusive Locks
          3. Update Locks
          4. Intent Locks
          5. Special Lock Modes
          6. Conversion Locks
          7. Key-Range Locks
        5. Lock Granularity
          1. Key Locks
          2. Additional Lock Resources
          3. Identifying Lock Resources
          4. Associated Entity ID
        6. Lock Duration
        7. Lock Ownership
        8. Viewing Locks
          1. sys.dm_tran_locks
            1. resource_ Columns
            2. request_ Columns
        9. Locking Examples
      4. Lock Compatibility
      5. Internal Locking Architecture
        1. Lock Partitioning
        2. Lock Blocks
        3. Lock Owner Blocks
        4. syslockinfo Table
      6. Row-Level Locking vs. Page-Level Locking
        1. Lock Escalation
          1. Controlling Lock Escalation
        2. Deadlocks
      7. Row Versioning
        1. Overview of Row Versioning
        2. Row Versioning Details
        3. Snapshot-Based Isolation Levels
          1. Read Committed Snapshot Isolation
          2. Snapshot Isolation
          3. Snapshot Isolation Scope
          4. Viewing Database State
          5. Update Conflicts
          6. Data Definition Language and SNAPSHOT Isolation
          7. Summary of Snapshot-Based Isolation Levels
          8. The Version Store
          9. Management of the Version Store
          10. Snapshot Transaction Metadata
        4. Choosing a Concurrency Model
      8. Controlling Locking
        1. Lock Hints
          1. Setting a Lock Timeout
      9. Summary
    14. 11. DBCC Internals
      1. Getting a Consistent View of the Database
        1. Obtaining a Consistent View
          1. Disk Space Issues
          2. Alternatives to Using a Database Snapshot
      2. Processing the Database Efficiently
        1. Fact Generation
        2. Using the Query Processor
        3. Batches
        4. Reading the Pages to Process
        5. Parallelism
      3. Primitive System Catalog Consistency Checks
      4. Allocation Consistency Checks
        1. Collecting Allocation Facts
        2. Checking Allocation Facts
      5. Per-Table Logical Consistency Checks
        1. Metadata Consistency Checks
        2. Page Audit
        3. Data and Index Page Processing
        4. Column Processing
          1. Computed Columns
          2. NULL and Length Checks
          3. Data Purity Checks
          4. Partitioning Checks
          5. Sparse Column Checks
        5. Text Page Processing
        6. Cross-Page Consistency Checks
          1. Heap Consistency Checks
          2. B-tree Consistency Checks
          3. LOB Linkage Consistency Checks
          4. FILESTREAM Consistency Checks
          5. Nonclustered Index Cross-Checks
      6. Cross-Table Consistency Checks
        1. Service Broker Consistency Checks
        2. Cross-Catalog Consistency Checks
        3. Indexed-View Consistency Checks
        4. XML-Index Consistency Checks
        5. Spatial-Index Consistency Checks
      7. DBCC CHECKDB Output
        1. Regular Output
          1. Error Reporting to Microsoft
        2. SQL Server Error Log Output
        3. Application Event Log Output
        4. Progress Reporting Output
      8. DBCC CHECKDB Options
        1. NOINDEX
        2. Repair Options
        3. ALL_ERRORMSGS
        4. EXTENDED_LOGICAL_CHECKS
        5. NO_INFOMSGS
        6. TABLOCK
        7. ESTIMATEONLY
        8. PHYSICAL_ONLY
        9. DATA_PURITY
      9. Database Repairs
        1. Repair Mechanisms
        2. Emergency Mode Repair
        3. What Data Was Deleted by Repair?
      10. Consistency-Checking Commands Other Than DBCC CHECKDB
        1. DBCC CHECKALLOC
        2. DBCC CHECKTABLE
        3. DBCC CHECKFILEGROUP
        4. DBCC CHECKCATALOG
        5. DBCC CHECKIDENT
        6. DBCC CHECKCONSTRAINTS
      11. Summary
    15. About the Authors
      1. Kalen Delaney
      2. Paul S. Randal
      3. Kimberly L. Tripp
      4. Conor Cunningham
      5. Adam Machanic
      6. Technical Reviewer: Benjamin Nevarez
    16. Index
    17. About the Authors
    18. Copyright