Apress SQL server 2008 transact SQL recipes a problem solution approach jul 2008 ISBN 1590599802 pdf

this print for content only—size & color not accurate spine = 1.635" 872 page countSQL Server 2008 Transact-SQL Recipes Dear Reader,Transact-SQL is SQL Server’s built-in database program

this print for content only—size & color not accurate spine = 1.635" 872 page count

SQL Server 2008 Transact-SQL Recipes

Dear Reader,Transact-SQL is SQL Server’s built-in database programming and query lan-guage You use it for writing everything from simple SELECT statements to complex stored procedures and functions Transact-SQL is the key to unlocking all of SQL Server’s rich functionality Newly updated for SQL Server 2008, the Transact-SQL language includes support for grouping sets, compound assign-ment operators, row constructors, inline variable initialization, table-valued parameters, sparse columns, the MERGE command, change tracking, granular auditing, data and backup compression, filtered indexes, Resource Governor, several new data types, and more

I wrote this book in a problem/solution format in order to establish an immediate understanding of a task and its associated Transact-SQL solution

Look up the task you want to perform, read how to do it, and then perform the task on your own system—it’s that simple My end goal is to allow you to quickly find the information you need in order to get the job done You can read this book

in sequential order or out of order, skipping around to topics that interest you

Although you can perform many tasks by using GUI tools such as SQL Server Management Studio, Transact-SQL flows beneath the majority of SQL Server’s features Becoming proficient with Transact-SQL improves your understanding

of the SQL Server engine, enhances troubleshooting skills, and bolsters your ability to support and maintain your SQL Server environment

The problem/solution format in this book allows you to quickly get familiar with a range of features and apply them right away in your own environment

Using this book, my hope is that you’ll discover new and effective approaches

to solving business problems using Transact-SQL, which will lead you to using SQL Server 2008 to its maximum potential

Best Regards,Joseph Sack, MCDBA, MCITP (DD), MCITP (DA)

Joseph Sack

Companion eBook Available

THE APRESS ROADMAP

AcceleratedSQL Server 2008

Beginning SQL Server

2008 for Developers

Pro T-SQL 2008Programmer’s Guide

SQL Server 2008Transact-SQL Recipes

SQL Server QueryPerformance Tuning Distilled,Second Edition

Expert SQL Server 2008 Development

9 781590 599808

5 5 9 9 9

Get the job done with SQL Server’s powerful database programming and query language

Joseph Sack

SQL Server 2008

Transact-SQL Recipes

SQL Server 2008 Transact-SQL Recipes

Copyright © 2008 by Joseph Sack

All rights reserved No part of this work may be reproduced or transmitted in any form or by any means,electronic or mechanical, including photocopying, recording, or by any information storage or retrievalsystem, without the prior written permission of the copyright owner and the publisher

ISBN-13 (pbk): 978-1-59059-980-8

ISBN-10 (pbk): 1-59059-980-2

ISBN-13 (electronic): 978-1-4302-0626-2

Printed and bound in the United States of America 9 8 7 6 5 4 3 2 1

Trademarked names may appear in this book Rather than use a trademark symbol with every occurrence

of a trademarked name, we use the names only in an editorial fashion and to the benefit of the trademarkowner, with no intention of infringement of the trademark

Lead Editor: Jonathan Gennick

Technical Reviewer: Evan Terry

Editorial Board: Clay Andres, Steve Anglin, Ewan Buckingham, Tony Campbell, Gary Cornell,

Jonathan Gennick, Matthew Moodie, Joseph Ottinger, Jeffrey Pepper, Frank Pohlmann, Ben Renow-Clarke, Dominic Shakeshaft, Matt Wade, Tom Welsh

Project Manager: Susannah Davidson Pfalzer

Copy Editor: Ami Knox

Associate Production Director: Kari Brooks-Copony

Production Editor: Laura Cheu

Compositor: Dina Quan

Proofreader: Liz Welch

Indexer: Brenda Miller

Artist: April Milne

Cover Designer: Kurt Krames

Manufacturing Director: Tom Debolski

Distributed to the book trade worldwide by Springer-Verlag New York, Inc., 233 Spring Street, 6th Floor,New York, NY 10013 Phone 1-800-SPRINGER, fax 201-348-4505, e-mail orders-ny@springer-sbm.com, orvisit http://www.springeronline.com

For information on translations, please contact Apress directly at 2855 Telegraph Avenue, Suite 600,Berkeley, CA 94705 Phone 510-549-5930, fax 510-549-5939, e-mail info@apress.com, or visit

http://www.apress.com

Apress and friends of ED books may be purchased in bulk for academic, corporate, or promotional use.eBook versions and licenses are also available for most titles For more information, reference our SpecialBulk Sales—eBook Licensing web page at http://www.apress.com/info/bulksales

The information in this book is distributed on an “as is” basis, without warranty Although every tion has been taken in the preparation of this work, neither the author(s) nor Apress shall have anyliability to any person or entity with respect to any loss or damage caused or alleged to be caused directly

precau-or indirectly by the infprecau-ormation contained in this wprecau-ork

Contents at a Glance

About the Author xxv

About the Technical Reviewer xxvii

Acknowledgments xxix

Introduction xxxi

■ CHAPTER 1 SELECT 1

■ CHAPTER 2 Perform, Capture, and Track Data Modifications 63

■ CHAPTER 3 Transactions, Locking, Blocking, and Deadlocking 115

■ CHAPTER 4 Tables 143

■ CHAPTER 5 Indexes 197

■ CHAPTER 6 Full-Text Search 217

■ CHAPTER 7 Views 239

■ CHAPTER 8 SQL Server Functions 257

■ CHAPTER 9 Conditional Processing, Control-of-Flow, and Cursors 307

■ CHAPTER 10 Stored Procedures 325

■ CHAPTER 11 User-Defined Functions and Types 343

■ CHAPTER 12 Triggers 373

■ CHAPTER 13 CLR Integration 401

■ CHAPTER 14 XML, Hierarchies, and Spatial Data 419

■ CHAPTER 15 Hints 449

■ CHAPTER 16 Error Handling 459

■ CHAPTER 17 Principals 475

■ CHAPTER 18 Securables, Permissions, and Auditing 501

■ CHAPTER 19 Encryption 547

■ CHAPTER 20 Service Broker 579

iv

■ CHAPTER 21 Configuring and Viewing SQL Server Options 615

■ CHAPTER 22 Creating and Configuring Databases 621

■ CHAPTER 23 Database Integrity and Optimization 669

■ CHAPTER 24 Maintaining Database Objects and Object Dependencies 687

■ CHAPTER 25 Database Mirroring 697

■ CHAPTER 26 Database Snapshots 717

■ CHAPTER 27 Linked Servers and Distributed Queries 723

■ CHAPTER 28 Query Performance Tuning 739

■ CHAPTER 29 Backup and Recovery 789

■ INDEX 823

v

About the Author xxv

About the Technical Reviewer xxvii

Acknowledgments xxix

Introduction xxxi

■ CHAPTER 1 SELECT 1

The Basic SELECT Statement 1

Selecting Specific Columns from a Table 2

Selecting Every Column for Every Row 3

Selective Querying Using a Basic WHERE Clause 3

Using the WHERE Clause to Specify Rows Returned in the Result Set 4

Combining Search Conditions 4

Negating a Search Condition 6

Keeping Your WHERE Clause Unambiguous 6

Using Operators and Expressions 7

Using BETWEEN for Date Range Searches 9

Using Comparisons 9

Checking for NULL Values 10

Returning Rows Based on a List of Values 11

Using Wildcards with LIKE 11

Declaring and Assigning Values to Variables 12

Grouping Data 14

Using the GROUP BY Clause 14

Using GROUP BY ALL 15

Selectively Querying Grouped Data Using HAVING 16

Ordering Results 17

Using the ORDER BY Clause 17

Using the TOP Keyword with Ordered Results 19

SELECT Clause Techniques 21

Using DISTINCT to Remove Duplicate Values 21

Using DISTINCT in Aggregate Functions 22

Using Column Aliases 22

Using SELECT to Create a Script 23

Performing String Concatenation 24

Creating a Comma-Delimited List Using SELECT 25

Using the INTO Clause 26

vii

Subqueries 27

Using Subqueries to Check for Matches 27

Querying from More Than One Data Source 28

Using INNER Joins 29

Using OUTER Joins 30

Using CROSS Joins 31

Referencing a Single Table Multiple Times in the Same Query 32

Using Derived Tables 33

Combining Result Sets with UNION 33

Using APPLY to Invoke a Table-Valued Function for Each Row 35

Using CROSS APPLY 35

Using OUTER APPLY 37

Advanced Techniques for Data Sources 38

Using the TABLESAMPLE to Return Random Rows 38

Using PIVOT to Convert Single Column Values into Multiple Columns and Aggregate Data 39

Normalizing Data with UNPIVOT 42

Returning Distinct or Matching Rows Using EXCEPT and INTERSECT 44

Summarizing Data 46

Summarizing Data Using CUBE 46

Summarizing Data Using ROLLUP 48

Creating Custom Summaries Using Grouping Sets 49

Revealing Rows Generated by GROUPING 51

Advanced Group-Level Identification with GROUPING_ID 53

Common Table Expressions 56

Using a Non-Recursive Common Table Expression 56

Using a Recursive Common Table Expression 59

■ CHAPTER 2 Perform, Capture, and Track Data Modifications 63

INSERT 63

Inserting a Row into a Table 64

Inserting a Row Using Default Values 65

Explicitly Inserting a Value into an IDENTITY Column 66

Inserting a Row into a Table with a uniqueidentifier Column 67

Inserting Rows Using an INSERT SELECT Statement 68

Inserting Data from a Stored Procedure Call 70

Inserting Multiple Rows with VALUES 71

Using VALUES As a Table Source 72

UPDATE 73

Updating a Single Row 74

Updating Rows Based on a FROM and WHERE Clause 75

Updating Large Value Data Type Columns 76

Inserting or Updating an Image File Using OPENROWSET and BULK 78

Storing Unstructured Data on the File System While Maintaining

SQL Server Transactional Control 80

Assigning and Modifying Database Values “in Place” 84

DELETE 86

Deleting Rows 86

Truncating a Table 88

Advanced Data Modification Techniques 89

Chunking Data Modifications with TOP 89

Executing INSERTs, UPDATEs, and DELETEs in a Single Statement 90

Capturing and Tracking Data Modification Changes 93

Returning Rows Affected by a Data Modification Statement 93

Asynchronously Capturing Table Data Modifications 96

Querying All Changes from CDC Tables 99

Querying Net Changes from CDC Tables 103

Translating the CDC Update Mask 104

Working with LSN Boundaries 105

Disabling Change Data Capture from Tables and the Database 107

Tracking Net Data Changes with Minimal Disk Overhead 107

■ CHAPTER 3 Transactions, Locking, Blocking, and Deadlocking 115

Transaction Control 115

Using Explicit Transactions 117

Displaying the Oldest Active Transaction with DBCC OPENTRAN 119

Querying Transaction Information by Session 120

Locking 122

Viewing Lock Activity 124

Controlling a Table’s Lock Escalation Behavior 126

Transaction, Locking, and Concurrency 128

Configuring a Session’s Transaction Locking Behavior 129

Blocking 134

Identifying and Resolving Blocking Issues 134

Configuring How Long a Statement Will Wait for a Lock to Be Released 136

Deadlocking 137

Identifying Deadlocks with a Trace Flag 138

Setting Deadlock Priority 141

■ CHAPTER 4 Tables 143

Table Basics 143

Creating a Table 147

Adding a Column to an Existing Table 147

Changing an Existing Column Definition 148

Creating a Computed Column 149

Reducing Storage for Null Columns 150

Dropping a Table Column 153

Reporting Table Information 154

Dropping a Table 154

Collation Basics 155

Viewing Collation Metadata 155

Designating a Column’s Collation 156

Keys 157

Creating a Table with a Primary Key 158

Adding a Primary Key Constraint to an Existing Table 159

Creating a Table with a Foreign Key Reference 160

Adding a Foreign Key to an Existing Table 161

Creating Recursive Foreign Key References 162

Allowing Cascading Changes in Foreign Keys 163

Surrogate Keys 165

Using the IDENTITY Property During Table Creation 165

Using DBCC CHECKIDENT to View and Correct IDENTITY Seed Values 166

Using the ROWGUIDCOL Property 168

Constraints 168

Creating a Unique Constraint 169

Adding a UNIQUE Constraint to an Existing Table 170

Using CHECK Constraints 171

Adding a CHECK Constraint to an Existing Table 172

Disabling and Enabling a Constraint 173

Using a DEFAULT Constraint During Table Creation 174

Adding a DEFAULT Constraint to an Existing Table 175

Dropping a Constraint from a Table 176

Temporary Tables and Table Variables 176

Using a Temporary Table for Multiple Lookups Within a Batch 177

Creating a Table Variable to Hold a Temporary Result Set 178

Manageability for Very Large Tables 180

Implementing Table Partitioning 181

Determining the Location of Data in a Partition 184

Adding a New Partition 186

Removing a Partition 188

Moving a Partition to a Different Table 189

Removing Partition Functions and Schemes 190

Easing VLDB Manageability with Filegroups 191

Reducing Disk Space Usage with Data Compression 192

■ CHAPTER 5 Indexes 197

Index Overview 197

Creating a Table Index 199

Enforcing Uniqueness on Non-Key Columns 201

Creating an Index on Multiple Columns 202

Defining Index Column Sort Direction 203

Viewing Index Meta Data 203

Disabling an Index 205

Dropping Indexes 206

Changing an Existing Index with DROP_EXISTING 206

Controlling Index Build Performance and Concurrency 207

Intermediate Index Creation in Tempdb 207

Controlling Parallel Plan Execution for Index Creation 208

Allowing User Table Access During Index Creation 208

Index Options 209

Using an Index INCLUDE 209

Using PAD_INDEX and FILLFACTOR 210

Disabling Page and/or Row Index Locking 211

Managing Very Large Indexes 212

Creating an Index on a Filegroup 212

Implementing Index Partitioning 213

Indexing a Subset of Rows 214

Reducing Index Size 215

■ CHAPTER 6 Full-Text Search 217

Full-Text Indexes and Catalogs 217

Creating a Full-Text Catalog 217

Creating a Full-Text Index 219

Modifying a Full-Text Catalog 221

Modifying a Full-Text Index 222

Retrieving Full-Text Catalog and Index Metadata 225

Discarding Common Strings from a Full-Text Index 226

Dropping a Full-Text Index 229

Dropping a Full-Text Catalog 230

Basic Searching 230

Using FREETEXT to Search Full-Text Indexed Columns 231

Using CONTAINS for Word Searching 232

Advanced Searching 232

Using CONTAINS to Search with Wildcards 233

Using CONTAINS to Search for Inflectional Matches 233

Using CONTAINS for Searching Results by Term Proximity 234

Ranked Searching 235

Returning Ranked Search Results by Meaning 235

Returning Ranked Search Results by Weighted Value 236

■ CHAPTER 7 Views 239

Regular Views 240

Creating a Basic View 240

Querying the View Definition 242

Displaying Views and Their Structures 243

Refreshing a View’s Definition 244

Modifying a View 245

Dropping a View 245

Modifying Data Through a View 246

View Encryption 247

Encrypting a View 247

Indexed Views 248

Creating an Indexed View 248

Forcing the Optimizer to Use an Index for an Indexed View 251

Partitioned Views 251

Creating a Distributed-Partitioned View 252

■ CHAPTER 8 SQL Server Functions 257

Aggregate Functions 257

Returning the Average of Values 258

Returning Row Counts 259

Finding the Lowest and Highest Values from an Expression 259

Returning the Sum of Values 260

Using Statistical Aggregate Functions 260

Mathematical Functions 261

Performing Mathematical Operations 262

String Functions 263

Converting a Character Value to ASCII and Back to Character 264

Returning Integer and Character Unicode Values 265

Finding the Start Position of a String Within Another String 266

Finding the Start Position of a String Within Another String Using Wildcards 266

Determining the Similarity of Strings 267

Taking the Leftmost or Rightmost Part of a String 268

Determining the Number of Characters or Bytes in a String 269

Replacing a Part of a String 269

Stuffing a String into a String 270

Changing Between Lower- and Uppercase 270

Removing Leading and Trailing Blanks 271

Repeating an Expression N Number of Times 272

Repeating a Blank Space N Number of Times 272

Outputting an Expression in Reverse Order 273

Returning a Chunk of an Expression 273

Working with NULLs 274

Replacing a NULL Value with an Alternative Value 274

Performing Flexible Searches Using ISNULL 275

Returning the First Non-NULL Value in a List of Expressions 276

Returning a NULL Value When Two Expressions Are Equal: Otherwise Returning the First Expression 277

Date Functions 277

Returning the Current Date and Time 278

Converting Between Time Zones 279

Incrementing or Decrementing a Date’s Value 280

Finding the Difference Between Two Dates 281

Displaying the String Value for Part of a Date 282

Displaying the Integer Representation for Parts of a Date 282

Displaying the Integer Value for Part of a Date Using YEAR, MONTH, and DAY 283

Type Conversion 284

Converting Between Data Types 284

Converting Dates to Their Textual Representation 285

Representing Binary Data in String Literals 286

Evaluating the Data Type Returned by an Expression 287

Ranking Functions 288

Generating an Incrementing Row Number 289

Returning Rows by Rank 290

Returning Rows by Rank Without Gaps 292

Using NTILE 292

Probing Server, Database, and Connection-Level Settings Using System Functions 293

Determining the First Day of the Week 293

Viewing the Language Used in the Current Session 294

Viewing and Setting Current Connection Lock Timeout Settings 295

Displaying the Nesting Level for the Current Stored Procedure Context 295

Returning the Current SQL Server Instance Name and SQL Server Version 296

Returning the Current Connection’s Session ID (SPID) 296

Returning the Number of Open Transactions 297

Retrieving the Number of Rows Affected by the Previous Statement 297

Retrieving System Statistics 298

Displaying Database and SQL Server Settings 299

Returning the Current Database ID and Name 300

Returning a Database Object Name and ID 301

Returning the Application and Host for the Current User Session 301

Reporting Current User and Login Context 302

Viewing User Connection Options 303

IDENTITY and uniqueidentifier Functions 303

Returning the Last Identity Value 304

Returning an Identity Column’s Seed and Incrementing Value 305

Creating a New uniqueidentifier Value 305

■ CHAPTER 9 Conditional Processing, Control-of-Flow, and Cursors 307

Conditional Processing 307

Using CASE to Evaluate a Single Input Expression 308

Using CASE to Evaluate Boolean Expressions 309

Using IF ELSE 310

Control-of-Flow 312

Using RETURN 313

Using WHILE 314

Using GOTO 316

Using WAITFOR 318

Cursors 319

Creating and Using Transact-SQL Cursors 321

■ CHAPTER 10 Stored Procedures 325

Stored Procedure Basics 325

Creating a Basic Stored Procedure 326

Creating a Parameterized Stored Procedure 328

Using OUTPUT Parameters 330

Modifying a Stored Procedure 332

Dropping Stored Procedures 332

Executing Stored Procedures Automatically at SQL Server Startup 333

Reporting Stored Procedure Metadata 334

Documenting Stored Procedures 335

Stored Procedure Security 335

Encrypting a Stored Procedure 336

Using EXECUTE AS to Specify the Procedure’s Security Context 337

Recompilation and Caching 340

RECOMPILE(ing) a Stored Procedure Each Time It Is Executed 341

Flushing the Procedure Cache 342

■ CHAPTER 11 User-Defined Functions and Types 343

UDF Basics 343

Creating Scalar User-Defined Functions 344

Creating Inline User-Defined Functions 349

Creating Multi-Statement User-Defined Functions 351

Modifying User-Defined Functions 354

Viewing UDF Metadata 356

Dropping User-Defined Functions 356

Benefitting from UDFs 357

Maintaining Reusable Code 357

Cross-Referencing Natural Key Values 359

Replacing Views with Multi-Statement UDFs 362

UDT Basics 365

Creating and Using User-Defined Types 365

Identifying Columns and Parameters with Dependencies on User-Defined Types 367

Dropping User-Defined Types 368

Passing Table-Valued Parameters 369

■ CHAPTER 12 Triggers 373

DML Triggers 374

Creating an AFTER DML Trigger 375

Creating an INSTEAD OF DML Trigger 378

Handling Transactions Within DML Triggers 381

Controlling DML Triggers Based on Modified Columns 384

Viewing DML Trigger Metadata 385

DDL Triggers 386

Creating a DDL Trigger That Audits Database-Level Events 387

Creating a DDL Trigger That Audits Server-Level Events 389

Using a Logon Trigger 390

Viewing DDL Trigger Metadata 392

Managing Triggers 393

Modifying a Trigger 393

Enabling and Disabling Table Triggers 394

Limiting Trigger Nesting 395

Controlling Trigger Recursion 396

Setting Trigger Firing Order 397

Dropping a Trigger 399

■ CHAPTER 13 CLR Integration 401

CLR Overview 402

When (and When Not) to Use Assemblies 402

CLR Objects Overview 404

Creating CLR Database Objects 404

Enabling CLR Support in SQL Server 405

Writing an Assembly for a CLR Stored Procedure 405

Compiling an Assembly into a DLL File 408

Loading the Assembly into SQL Server 409

Creating the CLR Stored Procedure 410

Creating a CLR Scalar User-Defined Function 412

Creating a CLR Trigger 415

Administering Assemblies 417

Viewing Assembly Metadata 417

Modifying an Assembly’s Permissions 417

Removing an Assembly from the Database 418

■ CHAPTER 14 XML, Hierarchies, and Spatial Data 419

Working with Native XML 419

Creating XML Data Type Columns 419

Inserting XML Data into a Column 421

Validating XML Data Using Schemas 422

Retrieving XML Data 424

Modifying XML Data 427

Indexing XML Data 428

Converting Between XML Documents and Relational Data 430

Formatting Relational Data As XML 430

Converting XML to a Relational Form 433

Working with Native Hierarchical Data 435

Storing Hierarchical Data 435

Returning a Specific Ancestor 438

Returning Child Nodes 439

Returning a Node’s Depth 440

Returning the Root Node 440

Determining Whether a Node Is a Child of the Current Node 441

Changing Node Locations 441

Native Spatial Data 442

Storing Spatial Data 442

Querying Spatial Data 445

■ CHAPTER 15 Hints 449

Using Join Hints 449

Forcing a HASH Join 450

Using Query Hints 451

Forcing a Statement Recompile 452

Using Table Hints 454

Executing a Query Without Locking 456

Forcing a SEEK over a SCAN 456

■ CHAPTER 16 Error Handling 459

System-Defined and User-Defined Error Messages 459

Viewing System Error Information 459

Creating a User-Defined Error Message 460

Dropping a User-Defined Error Message 462

Manually Raising an Error 462

Invoking an Error Message 463

Trapping and Handling Application Errors 465

Old-Style Error Handling 466

Error Handling with TRY CATCH 468

Applying Error Handling Without Recoding a Stored Procedure 470

Nesting Error Handling 471

■ CHAPTER 17 Principals 475

Windows Principals 475

Creating a Windows Login 476

Viewing Windows Logins 477

Altering a Windows Login 478

Dropping a Windows Login 479

Denying SQL Server Access to a Windows User or Group 480

SQL Server Principals 480

Creating a SQL Server Login 482

Viewing SQL Server Logins 482

Altering a SQL Server Login 483

Managing a Login’s Password 484

Dropping a SQL Login 485

Managing Server Role Members 485

Reporting Fixed Server Role Information 486

Database Principals 488

Creating Database Users 489

Reporting Database User Information 490

Modifying a Database User 490

Removing a Database User from the Database 491

Fixing Orphaned Database Users 491

Reporting Fixed Database Roles Information 493

Managing Fixed Database Role Membership 494

Managing User-Defined Database Roles 495

Managing Application Roles 497

■ CHAPTER 18 Securables, Permissions, and Auditing 501

Permissions Overview 502

Reporting SQL Server Assignable Permissions 503

Server-Scoped Securables and Permissions 505

Managing Server Permissions 507

Querying Server-Level Permissions 508

Database-Scoped Securables and Permissions 509

Managing Database Permissions 510

Querying Database Permissions 511

Schema-Scoped Securables and Permissions 514

Managing Schemas 516

Managing Schema Permissions 517

Object Permissions 519

Managing Object Permissions 521

Managing Permissions Across Securable Scopes 522

Determining a Current Connection’s Permissions to a Securable 522

Reporting the Permissions for a Principal by Securable Scope 523

Changing Securable Ownership 527

Allowing SQL Logins to Access Non-SQL Server Resources 528

Auditing SQL Instance and Database-Level Activity of Principals Against Securables 529

Defining Audit Data Sources 530

Capturing SQL Instance–Scoped Events 533

Capturing Database-Scoped Events 535

Querying Captured Audit Data 539

Managing, Modifying, and Removing Audit Objects 543

■ CHAPTER 19 Encryption 547

Encryption by Passphrase 547

Using a Function to Encrypt by Passphrase 548

Master Keys 550

Backing Up and Restoring a Service Master Key 550

Creating, Regenerating, and Dropping a Database Master Key 551

Backing Up and Restoring a Database Master Key 553

Removing Service Master Key Encryption from the Database Master Key 554

Asymmetric Key Encryption 555

Creating an Asymmetric Key 555

Viewing Asymmetric Keys in the Current Database 556

Modifying the Asymmetric Key’s Private Key Password 557

Encrypting and Decrypting Data Using an Asymmetric Key 557

Dropping an Asymmetric Key 560

Symmetric Key Encryption 560

Creating a Symmetric Key 560

Viewing Symmetric Keys in the Current Database 562

Changing How a Symmetric Key Is Encrypted 562

Using Symmetric Key Encryption and Decryption 563

Dropping a Symmetric Key 567

Certificate Encryption 567

Creating a Database Certificate 567

Viewing Certificates in the Database 568

Backing Up and Restoring a Certificate 569

Managing a Certificate’s Private Key 570

Using Certificate Encryption and Decryption 571

Automatically Opening and Decrypting via a Symmetric Key 573

Transparent Data Encryption 575

Enabling Transparent Data Encryption 575

Managing and Removing TDE 576

■ CHAPTER 20 Service Broker 579

Example Scenario: Online Bookstore 580

Creating a Basic Service Broker Application 580

Enabling Databases for Service Broker Activity 581

Creating the Database Master Key for Encryption 582

Managing Message Types 582

Creating Contracts 584

Creating Queues 585

Creating Services 587

Initiating a Dialog 589

Querying the Queue for Incoming Messages 591

Receiving and Responding to a Message 591

Ending a Conversation 594

Prioritizing Service Broker Conversations 596

Creating a Stored Procedure to Process Messages 598

Creating the Bookstore Stored Procedure 598

Remote-Server Service Broker Implementations 601

Enabling Transport Security 603

Enabling Dialog Security 606

Creating Routes and Remote Service Bindings 608

Event Notifications 612

Capturing Login Commands 612

■ CHAPTER 21 Configuring and Viewing SQL Server Options 615

Viewing SQL Server Configurations 615

Changing SQL Server Configurations 617

■ CHAPTER 22 Creating and Configuring Databases 621

Creating, Altering, and Dropping Databases 621

Creating a Database with a Default Configuration 622

Viewing Database Information 622

Creating a Database Using File Options 624

Creating a Database with a User-Defined Filegroup 627

Setting Database User Access 628

Renaming a Database 631

Dropping a Database 632

Detaching a Database 632

Attaching a Database 634

Configuring Database Options 635

Viewing Database Options 636

Configuring ANSI SQL Options 636

Configuring Automatic Options 638

Creating or Modifying a Database to Allow External Access 640

Creating or Changing a Database to Use a Non-Server Default Collation 641

Configuring Cursor Options 642

Enabling Date Correlation Optimization 643

Modifying Database Parameterization Behavior 644

Enabling Read Consistency for a Transaction 647

Configuring Database Recovery Models 649

Configuring Page Verification 650

Controlling Database Access and Ownership 651

Changing a Database State to Online, Offline, or Emergency 652

Changing a Database Owner 653

Managing Database Files and Filegroups 654

Adding a Data File or Log File to an Existing Database 654

Removing a Data or Log File from a Database 656

Relocating a Data or Transaction Log File 657

Changing a File’s Logical Name 658

Increasing a Database’s File Size and Modifying Its Growth Options 659

Adding a Filegroup to an Existing Database 660

Setting the Default Filegroup 660

Removing a Filegroup 661

Making a Database or Filegroup Read-Only 662

Viewing and Managing Database Space Usage 663

Viewing Database Space Usage 663

Shrinking the Database or a Database File 665

■ CHAPTER 23 Database Integrity and Optimization 669

Database Integrity Checking 669

Checking Consistency of the Disk Space Allocation Structures with DBCC CHECKALLOC 670

Checking Allocation and Structural Integrity with DBCC CHECKDB 672

Tables and Constraints 674

Checking Allocation and Structural Integrity of All Tables in

a Filegroup Using DBCC CHECKFILEGROUP 675

Checking Data Integrity for Tables and Indexed Views Using DBCC CHECKTABLE 676

Checking Table Integrity with DBCC CHECKCONSTRAINTS 679

Checking System Table Consistency with DBCC CHECKCATALOG 681

Database Object Maintenance 687

Changing the Name of a User-Created Database Object 687

Changing an Object’s Schema 689

Object Dependencies 690

Identifying Object Dependencies 690

Identifying Referencing and Referenced Entities 692

Viewing an Object’s Definition 694

■ CHAPTER 25 Database Mirroring 697

Database Mirroring in Context 697

Database Mirroring Architecture 698

Setting Up Database Mirroring 700

Creating Mirroring Endpoints 700

Backing Up and Restoring Principal Databases 705

Creating a Database Mirroring Session 707

Setup Summary 709

Operating Database Mirroring 710

Changing Operating Modes 711

Performing Failovers 712

Pausing or Resuming a Mirroring Session 713

Stopping Mirroring Sessions and Removing Endpoints 714

Monitoring and Configuring Options 714

Monitoring Mirror Status 714

Configuring the Connection Timeout Period 715

■ CHAPTER 26 Database Snapshots 717

Snapshot Basics 717

Creating and Querying Database Snapshots 718

Removing a Database Snapshot 719

Recovering Data with a Database Snapshot 720

■ CHAPTER 27 Linked Servers and Distributed Queries 723

Linked Server Basics 723

Creating a Linked Server to Another SQL Server Instance 724

Configuring Linked Server Properties 725

Viewing Linked Server Information 727

Dropping a Linked Server 727

Linked Server Logins 728

Adding a Linked Server Login Mapping 728

Viewing Linked Logins 729

Dropping a Linked Server Login Mapping 730

Executing Distributed Queries 730

Executing Distributed Queries Against a Linked Server 730

Creating and Using an Alias to Reference Four-Part Linked Server Names 732

Executing Distributed Queries Using OPENQUERY 733

Executing Ad Hoc Queries Using OPENROWSET 733

Reading Data from a File Using OPENROWSET BULK Options 735

■ CHAPTER 28 Query Performance Tuning 739

Query Performance Tips 740

Capturing and Evaluating Query Performance 742

Capturing Executing Queries Using sys.dm_exec_requests 742

Viewing Estimated Query Execution Plans Using Transact-SQL Commands 743

Viewing Execution Runtime Information 746

Viewing Performance Statistics for Cached Query Plans 748

Viewing Aggregated Performance Statistics Based on Query

or Plan Patterns 750

Identifying the Top Bottleneck 752

Identifying I/O Contention by Database and File 753

Index Tuning 754

Displaying Index Fragmentation 756

Displaying Index Usage 759

Statistics 760

Manually Creating Statistics 760

Creating Statistics on a Subset of Rows 761

Updating Statistics 762

Generating and Updating Statistics Across All Tables 763

Viewing Statistics Details 765

Removing Statistics 766

Miscellaneous Techniques 766

Using an Alternative to Dynamic SQL 767

Forcing SQL Server to Use a Query Plan 769

Applying Hints Without Modifying Application SQL 771

Creating Plan Guides from Cache 775

Checking the Validity of a Plan Guide 777

Parameterizing a Non-parameterized Query Using Plan Guides 778

Limiting Competing Query Resource Consumption 781

■ CHAPTER 29 Backup and Recovery 789

Creating a Backup and Recovery Plan 789

Making Backups 791

Performing a Basic Full Backup 793

Compressing Your Backups 794

Naming and Describing Your Backups and Media 796

Configuring Backup Retention 797

Striping Backup Sets 799

Using a Named Backup Device 799

Mirroring Backup Sets 801

Performing a Transaction Log Backup 803

Create Backups Without Breaking the Backup Sequence 804

Performing a Differential Backup 805

Backing Up Individual Files or Filegroups 805

Performing a Partial Backup 807

Viewing Backup Metadata 808

Restoring a Database 810

Restoring a Database from a Full Backup 810

Restoring a Database from a Transaction Log Backup 812

Restoring a Database from a Differential Backup 815

Restoring a File or Filegroup 816

Performing a Piecemeal (PARTIAL) Restore 818

Restoring a Page 819

Identifying Databases with Multiple Recovery Paths 820

■ INDEX 823

About the Author

■ JOSEPH SACKis a dedicated support engineer in the Microsoft Premier FieldEngineering organization and has worked with SQL Server since 1997 He isthe author of SQL Server 2005 T-SQL Recipes (Apress, 2005) and SQL Server

2000 Fast Answers for DBAs and Developers (Apress, 2005) He coauthored Pro SQL Server 2005 (Apress, 2005) and Beginning SQL Server 2000 DBA: From Novice to Professional (Apress, 2004) Joseph graduated with an associate’s

degree in arts from Bard College at Simon’s Rock and earned a bachelor’sdegree in psychology from the University of Minnesota You can reach Joseph

on his blog, www.joesack.com

xxv

About the Technical Reviewer

■ EVAN TERRYis the chief technical consultant for The Clegg Company,specializing in data management and information architecture His pastand current clients include the State of Idaho, Albertsons, American HondaMotors, Toyota Motor Sales, The Polk Company, and General Motors He isthe coauthor of Apress’s Beginning Relational Data Modeling, has published

articles in DM Review, and has presented at the IAIDQ and DAMA

Interna-tional conferences For questions or consulting needs, Evan can be contacted

at evan_terry@cleggcompany.com

xxvii

This book is dedicated to David Hatch, and to the family members, friends, and coworkers who

helped us get through a very challenging year From Guillain-Barré syndrome to a broken foot—you

were there for us, and we are very lucky to have you in our lives

During the 9-month writing process, the Apress team helped facilitate a very positive andsmooth experience I want to thank the lead editor, Jonathan Gennick, who was responsive, collab-

orative, and an all-around great guy to work with I also appreciate Evan Terry’s astute and detailed

technical editing—thanks for coming back for a second round!

I also want to thank the amazing Susannah Davidson Pfalzer for her excellent project ment skills and positive voice Thank you also to the keen-eyed Ami Knox, who put the critical

manage-finishing touches on this work, and also to Laura Cheu, for the production editing and patience

with my last-minute changes

Lastly—thank you to the rest of the behind-the-scenes Apress team who I may not have metover e-mail or the phone, but who still deserve credit for bringing this book to the market

xxix

The purpose of this book is to quickly provide you with the skills you need to solve problems and

perform tasks using the Transact-SQL language I wrote this book in a problem/solution format in

order to establish an immediate understanding of a task and its associated Transact-SQL solution

You can use this book to look up the task you want to perform, read how to do it, and then perform

the task on your own system While writing this book, I followed a few key tenets:

• Keep it brief, providing just enough information needed to get the job done

• Allow recipes and chapters to stand alone—keeping cross-references and distractions to atolerable minimum

• Focus on features that are typically implemented entirely using Transact-SQL For example,

I cover the new Resource Governor feature because it will typically be deployed by DBAsusing Transact-SQL—whereas I do not cover Policy-Based Management due to its underlyingdependencies on SQL Server Agent, SQL Server Management Objects (SMO), and SQL ServerManagement Studio Fortunately, most of the new SQL Server engine improvements are

entirely Transact-SQL based, and therefore are included in this book

• Write recipes that help a range of skill sets, from novice to professional I begin each chapterwith basic recipes and progressively work up to more advanced topics

Regarding new SQL Server 2008 features, I have interwoven them throughout the book in thechapters where they apply If you are just looking for a refresh on new Transact-SQL features, I

specifically call them out at the beginning of each chapter in which they exist

Although a key tenet of this book is to keep things brief, you’ll notice that this book is still quitelarge This is a consequence of the continually expanding SQL Server feature set; however, rest

assured that the recipes contained within are still succinct and constructed in such a way as to

quickly give you the answers you need to get the job done

I’ve written this book for SQL Server developers, administrators, application developers, and ITgeneralists who are tasked with developing databases or administering a SQL Server environment

You can read this book from start to finish or jump around to topics that interest you You can use

this book to brush up on topics before a job interview or an exam Even for the more experienced

SQL Server professionals, memory fades—and this book can help quickly refresh your memory on

the usage of a command or technique

Thanks for reading!

xxxi

In this chapter, I include recipes for returning data from a SQL Server database using the SELECT

statement At the beginning of each chapter, you’ll notice that most of the basic concepts are

cov-ered first This is for those of you who are new to the SQL Server 2008 Transact-SQL query language

In addition to the basics, I’ll also provide recipes that can be used in your day-to-day development

and administration These recipes will also help you learn about the new functionality introduced

in SQL Server 2008

A majority of the examples in this book use the AdventureWorks database (SQL Server 2008OLTP version), which can be downloaded online from the CodePlex site (www.codeplex.com),

under the “Microsoft SQL Server Product Samples: Database” project Look for the file named

AdventureWorks2008.msi Also, if you do decide to follow along with the recipe examples, I strongly

recommend that you do so with a non-production learning environment This will give you the

freedom to experiment without negative consequences

Brevity and simplicity is a key tenet of this book, so when initially describing a new T-SQLconcept, I’ll distill syntax blocks down to only the applicable code required If an example doesn’t

require a syntax block in order to illustrate a concept or task, I won’t include one For full syntax, you

can always reference Books Online, so instead of rehashing what you’ll already have access to, I’ll

focus only on the syntax that applies to the recipe Regarding the result sets returned from the

recipes in this book, I’ll often pare down the returned columns and rows shown on the page

SQL Server 2008 new features will be interwoven throughout the book For those more cant improvements, I’ll call them out at the beginning of the chapter so that you know to look out

signifi-for them The new SQL Server 2008 features I cover in this chapter include

• New extensions to the GROUP BY clause that allow you to generate multiple grouping resultsets within the same query without having to use UNION ALL

• A new method of initializing a variable on declaration, allowing you to reduce the codeneeded to set a variable’s value

You can read the recipes in this book in almost any order You can skip to the topics that est you or read it through sequentially If you see something that is useful to you, perhaps a code

inter-chunk or example that you can modify for your own purposes or integrate into a stored procedure

or function, then this book has been successful

The Basic SELECT Statement

The SELECT command is the cornerstone of the Transact-SQL language, allowing you to retrieve data

from a SQL Server database (and more specifically from database objects within a SQL Server

data-base) Although the full syntax of the SELECT statement is enormous, the basic syntax can be

presented in a more boiled-down form:

1

C H A P T E R 1

SELECT select_list

FROM table_list

The select_list argument shown in the previous code listing is the list of columns that youwish to return in the results of the query The table_list arguments are the actual tables and orviews that the data will be retrieved from

The next few recipes will demonstrate how to use a basic SELECT statement

Selecting Specific Columns from a Table

This example demonstrates a very simple SELECT query against the AdventureWorks database,whereby three columns are returned, along with several rows from the HumanResources.Employeetable Explicit column naming is used in the query:

USE AdventureWorks

GO

SELECT NationalIDNumber,

LoginID,JobTitleFROM HumanResources.Employee

The query returns the following abridged results:

295847284 adventure-works\ken0 Chief Executive Officer

245797967 adventure-works\terri0 Vice President of Engineering

509647174 adventure-works\roberto0 Engineering Manager

112457891 adventure-works\rob0 Senior Tool Designer

954276278 adventure-works\rachel0 Sales Representative

668991357 adventure-works\jae0 Sales Representative

134219713 adventure-works\ranjit0 Sales Representative

(290 row(s) affected)

How It Works

The first line of code sets the context database context of the query Your initial database context,when you first log in to SQL Server Management Studio (SSMS), is defined by your login’s defaultdatabase USE followed by the database name changes your connection context:

FROM HumanResources.Employee

The FROM clause is used to specify the data source, which in this example is a table Notice the

two-part name of HumanResources.Employee The first part (the part before the period) is the schema,

and the second part (after the period) is the actual table name A schema contains the object, and

that schema is then owned by a user Because users own a schema, and the schema contains the

object, you can change the owner of the schema without having to modify object ownership

Selecting Every Column for Every Row

If you wish to show all columns from the data sources in the FROM clause, you can use the following

The abridged column and row output is shown here:

BusinessEntityID NationalIDNumber LoginID OrganizationNode

The asterisk symbol (*) returns all columns for every row of the table or view you are querying All

other details are as explained in the previous recipe

Please remember that, as good practice, it is better to explicitly reference the columns youwant to retrieve instead of using SELECT * If you write an application that uses SELECT *, your

application may expect the same columns (in the same order) from the query If later on you add a

new column to the underlying table or view, or if you reorder the table columns, you could break

the calling application, because the new column in your result set is unexpected Using SELECT *

can also negatively impact performance, as you may be returning more data than you need over the

network, increasing the result set size and data retrieval operations on the SQL Server instance For

applications requiring thousands of transactions per second, the number of columns returned in

the result set can have a non-trivial impact

Selective Querying Using a Basic WHERE Clause

In a SELECT query, the WHERE clause is used to restrict rows returned in the query result set The

sim-plified syntax for including the WHERE clause is as follows:

UNKNOWN values can make their appearance when NULL data is accessed in the search condition.

A NULL value doesn’t mean that the value is blank or zero—only that the value is unknown Also, two

NULL values are not equal and cannot be compared without producing an UNKNOWN result.

The next few recipes will demonstrate how to use the WHERE clause to specify which rows areand aren’t returned in the result set

Using the WHERE Clause to Specify Rows Returned in the

Result Set

This basic example demonstrates how to select which rows are returned in the query results:SELECT Title,

FirstName,LastNameFROM Person.Person

WHERE Title = 'Ms.'

This example returns the following (abridged) results:

Title FirstName LastName

Combining Search Conditions

This recipe will demonstrate connecting multiple search conditions by utilizing the AND, OR, and NOTlogical operators The AND logical operator joins two or more search conditions and returns the row

or rows only when each of the search conditions is true The OR logical operator joins two or moresearch conditions and returns the row or rows in the result set when any of the conditions are true.

In this first example, two search conditions are used in the WHERE clause, separated by the ANDoperator The AND means that for a given row, both search conditions must be true for that row to bereturned in the result set:

SELECT Title,

FirstName,LastName

FROM Person.Person

WHERE Title = 'Ms.' AND

LastName = 'Antrim'This returns the following results:

Title FirstName LastName

WHERE Title = 'Ms.' OR

LastName = 'Antrim'This returns the following (abridged) results:

Title FirstName LastName

In the first example, two search conditions were joined using the AND operator:

WHERE Title = 'Ms.' AND

LastName = 'Antrim'

As you add search conditions to your query, you join them by the logical operators AND and OR

For example, if both the Title equals Ms and the LastName equals Antrim, any matching row or rows

will be returned The AND operator dictates that both joined search conditions must be true in order

for the row to be returned

The OR operator, on the other hand, returns rows if either search condition is TRUE, as the third

example demonstrated:

WHERE Title = 'Ms.' OR

LastName = 'Antrim'

So instead of a single row as the previous query returned, rows with a Title of Ms or a LastName

of Antrim were returned

Negating a Search Condition

The NOT logical operator, unlike AND and OR, isn’t used to combine search conditions, but instead isused to negate the expression that follows it

This next example demonstrates using the NOT operator for reversing the result of the following

search condition and qualifying the Title to be equal to Ms (reversing it to anything but Ms.):

SELECT Title,

FirstName,LastNameFROM Person.Person

WHERE NOT Title = 'Ms.'

This returns the following (abridged) results:

Title FirstName LastName

This example demonstrated the NOT operator:

WHERE NOT Title = 'Ms.'

NOT specifies the reverse of a search condition, in this case specifying that only rows that don’t

have the Title equal to Ms be returned

Keeping Your WHERE Clause Unambiguous

You can use multiple operators (AND, OR, NOT) in a single WHERE clause, but it is important to makeyour intentions clear by properly embedding your ANDs and ORs in parentheses The AND operatorlimits the result set, and the OR operator expands the conditions for which rows will be returned.When multiple operators are used in the same WHERE clause, operator precedence is used to deter-mine how the search conditions are evaluated (similar to order of operations used in arithmetic andalgebra) For example, the NOT operator takes precedence (is evaluated first) before AND The ANDoperator takes precedence over the OR operator Using both AND and OR operators in the same WHEREclause without using parentheses can return unexpected results

For example, the following query may return unintended results:

SELECT Title,

FirstName,LastNameFROM Person.Person

WHERE Title = 'Ms.' AND

FirstName = 'Catherine' ORLastName = 'Adams'