Mastering SQL server 2008 047028904X, 978-0-470-28904-4

Citation preview

Michael Lee Gentry Bieker

MASTERING Microsoft

®

SQL Server 2008 ®

Install, Configure, and Manage SQL Server 2008

SERIOUS SKILLS.

Optimize, Troubleshoot, and Secure Your Database

Mastering SQL Server® 2008

Mastering SQL Server® 2008 Michael Lee Gentry Bieker

Acquisitions Editor: Agatha Kim Development Editor: Laurene Sorensen Technical Editor: Acey Bunch Production Editor: Christine O’Connor Copy Editor: Kathy Grider-Carlyle Production Manager: Tim Tate Vice President and Executive Group Publisher: Richard Swadley Vice President and Publisher: Neil Edde Book Designer: Maureen Forys, Happenstance Type-O-Rama; Judy Fung Compositor: Jeffrey Lytle, Happenstance Type-O-Rama Proofreader: Scott Klemp, Word One Cover Designer: Ryan Sneed Cover Image: © Pete Gardner / Digital Vision / Getty Images Copyright © 2009 by Wiley Publishing, Inc., Indianapolis, Indiana Published simultaneously in Canada ISBN: 978-0-470-28904-4 No part of this publication may be reproduced, stored in a retrieval system or transmitted in any form or by any means, electronic, mechanical, photocopying, recording, scanning or otherwise, except as permitted under Sections 107 or 108 of the 1976 United States Copyright Act, without either the prior written permission of the Publisher, or authorization through payment of the appropriate per-copy fee to the Copyright Clearance Center, 222 Rosewood Drive, Danvers, MA 01923, (978) 750-8400, fax (978) 646-8600. Requests to the Publisher for permission should be addressed to the Permissions Department, John Wiley & Sons, Inc., 111 River Street, Hoboken, NJ 07030, (201) 748-6011, fax (201) 748-6008, or online at http://www.wiley.com/go/permissions. Limit of Liability/Disclaimer of Warranty: The publisher and the author make no representations or warranties with respect to the accuracy or completeness of the contents of this work and specifically disclaim all warranties, including without limitation warranties of fitness for a particular purpose. No warranty may be created or extended by sales or promotional materials. The advice and strategies contained herein may not be suitable for every situation. This work is sold with the understanding that the publisher is not engaged in rendering legal, accounting, or other professional services. If professional assistance is required, the services of a competent professional person should be sought. Neither the publisher nor the author shall be liable for damages arising herefrom. The fact that an organization or Web site is referred to in this work as a citation and/or a potential source of further information does not mean that the author or the publisher endorses the information the organization or Web site may provide or recommendations it may make. Further, readers should be aware that Internet Web sites listed in this work may have changed or disappeared between when this work was written and when it is read. For general information on our other products and services or to obtain technical support, please contact our Customer Care Department within the U.S. at (800) 762-2974, outside the U.S. at (317) 572-3993 or fax (317) 572-4002. Wiley also publishes its books in a variety of electronic formats. Some content that appears in print may not be available in electronic books. Library of Congress Cataloging-in-Publication Data Lee, Michael. Mastering SQL server 2008 / Michael Lee, Gentry Bieker. — 1st ed. p. cm. Includes index. ISBN 978-0-470-28904-4 (paper/website) 1. Client/server computing. 2. SQL server. 3. Relational databases. I. Bieker, Gentry. II. Title. QA76.9.C55L45 2009 005.75’85—dc22 2008042924 TRADEMARKS: Wiley, the Wiley logo, and the Sybex logo are trademarks or registered trademarks of John Wiley & Sons, Inc. and/or its affiliates, in theUnited Statesand other countries, and may not be used without written permission. SQL Server is a registered trademark of Microsoft Corporation in the United States and/or other countries. All other trademarks are the property of their respective owners. Wiley Publishing, Inc., is not associated with any product or vendor mentioned in this book. 10 9 8 7 6 5 4 3 2 1

Dear Reader, Thank you for choosing Mastering SQL Server 2008. This book is part of a family of premiumquality Sybex books, all of which are written by outstanding authors who combine practical experience with a gift for teaching. Sybex was founded in 1976. More than thirty years later, we’re still committed to producing consistently exceptional books. With each of our titles we’re working hard to set a new standard for the industry. From the paper we print on, to the authors we work with, our goal is to bring you the best books available. I hope you see all that reflected in these pages. I’d be very interested to hear your comments and get your feedback on how we’re doing. Feel free to let me know what you think about this or any other Sybex book by sending me an email at [email protected], or if you think you’ve found a technical error in this book, please visit http://sybex.custhelp.com. Customer feedback is critical to our efforts at Sybex. Best regards,

Neil Edde Vice President and Publisher Sybex, an Imprint of Wiley

To our students, who forced us to continually improve.

Acknowledgments Every project of this size is always an intense collaboration. This was certainly no exception. It all starts with the wonderful team at Sybex. This is the seventh project that I have worked on with the Sybex team, and I am always impressed by the work that they do. Special thanks to Neil Edde, Pete Gaughan, and Agatha Kim for their magnificent work on managing this process. Thanks also to our editor, Laurene Sorensen, who was able to merge our ideas together and help us to make the technical content actually readable. And thanks to the production team of Christine O’Connor, Kathy Grider-Carlyle, and Scott Klemp. Acey Bunch was a spectacular technical editor; an accomplished author in his own right, he provided many insights on the content that proved invaluable and substantially improved the quality of the content. Gentry Bieker, my coauthor on this project, was able to really capture the essence of SQL Server in the real world, something with which he has extensive experience. The production team at Sybex is superb. They were even able to take my hand drawings and turn them into real graphics, a true feat if you have ever seen my handwriting. Finally, on a personal note, my career in training and technology would never have taken off had it not been for a former mentor, Bob Taylor. Other colleagues including Jon Hansen, Dale Byrd, Bryan Bechtoldt, Ken Sandlin, and Mike Mansfield have contributed so much to my career and given me amazing support over the years. Additionally, most of this work was written while I was employed at Aristocrat Technologies in Las Vegas, and I need to thank my colleagues and the management there for their support and input. And of course, I need to offer special thanks to my family, my wife and son, who always pay the highest price for these projects as I lock myself into the office every weekend to write. They have been incredibly supportive as the process continued week after week, and I could not have done it without them. Most importantly, thanks to you, the reader. You are the reason for this project in the first place. I hope that you find value in the pages. Without you, we would not have had this incredible opportunity. Your feedback is invaluable and will help make any future projects better and more relevant. Good luck in your undertakings with SQL Server 2008. I wish you the best in your endeavors. —Michael Lee I’m incredibly thankful for the level of support I’ve received from everyone while writing my portion of this book. Thanks to Jennifer Hanner for all of the sacrifices she made, and the trips she allowed me to miss in order to complete this book, helping to keep me sane, and encouraging me to keep going through the process. To Samantha and Joel, my children, who went on many trips and outings without me through during the writing process. They made me smile, and reminded me that there is more to life than just a book. To Joel: “Yes, I’m finally done with my chapter!” To Michael Lee, who gave me this fantastic opportunity and introduced me to the process, and has always been patient and understanding in my learning about what it takes to put together a book of this size. Thanks to the entire book team: Laurene Sorensen, Acey Bunch, Pete Gaughan, Agatha Kim, and Neil Edde. I had an incredible amount of help and support from everyone I’ve encountered at Sybex and Wiley. You have all given me a ton of respect for the process that goes into creating a book. And to every one of my students (especially the difficult ones), who helped me to make it to where I am today. —Gentry Bieker

About the Authors Michael Lee (MCT, MCPD, MCITP, SCJP) has spent the last 15 years in technology training and consulting. Most of his career has been spent working with companies and helping them ease the transition to new technologies and practices. With a degree in Business Finance from the University of Utah, Michael discovered early that he enjoyed the IT aspects of business and built a career bringing together businesses and IT professionals, helping them understand each other and improve communication. His beginnings in IT were a bit dubious, having worked as an intern with IBM in 1988 on the FAA modernization project (AAS), which has been dubbed one of the greatest project failures in IT history. A lot was learned from that experience, and since then, his focus has been bringing together business and technology interests. As a former Microsoft Regional Director, he was heavily involved in the rollout of Visual Studio 6.0 in 1997 and has made a career out of melding business and technology into a unified strategic front. Currently, Michael is employed with the Clark County Court System in Las Vegas, Nevada where he still gets a chance to get his hands dirty with all kinds of technology, applying his passion to the public sector. When he is not coding, writing, or spending time with family, you can usually find him on his Harley, looking for that next great American Road. Gentry Bieker is a certified trainer, consultant, and mentor who has focused on SQL Server and related technologies for the last decade. His experience spans from database design and tuning to application development and enterprise application integration. He has developed numerous presentations, classes, and sessions on SQL Server and many of the other Microsoft technologies that work with SQL Server. In addition to SQL Server, he also focuses on SharePoint and Microsoft CRM. He has worked with customers in many industries, spanning from health care and insurance to casino gaming and manufacturing. As an energetic and passionate individual, he has found that turning massive amounts of data into useful information is what gets him up in the morning. He’s provided training, mentoring, and consulting services for many companies, large and small, including Microsoft, Unisys, and Kimberly-Clark. In his spare time, he enjoys spending time with his children, jumping out of perfectly good airplanes, and gaming.

Contents at a Glance Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxiii Chapter 1฀ •฀ Overview of Microsoft SQL Server 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 Chapter 2฀ •฀ Understanding SQL Server Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . 35 Chapter 3฀ •฀ Databases, Files, and Resource Management . . . . . . . . . . . . . . . . . . . . . . . 65 Chapter 4฀ •฀ Tables and CRUD Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Chapter 5฀ •฀ Procedural Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Chapter 6฀ •฀ Managing Data Integrity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Chapter 7฀ •฀ SQL Server and XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Chapter 8฀ •฀ Managing User Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223 Chapter 9฀ •฀ Data Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253 Chapter 10฀ •฀ Monitoring SQL Server Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283 Chapter 11฀ •฀ Using the SQL Server Agent Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319 Chapter 12฀ •฀ Data Availability and Distribution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349 Chapter 13฀ •฀ SQL Server Data Security. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389 Chapter 14฀ •฀ Indexing Strategies for Query Optimization . . . . . . . . . . . . . . . . . . . . . 415 Chapter 15฀ •฀ Transactions and Locking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443 Chapter 16฀ •฀ Using the Resource Governor and Policy-Based Management . . . . . . 473 Chapter 17฀ •฀ SQL Server and the .NET Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503 Chapter 18฀ •฀ SQL Server and the Common Language Runtime. . . . . . . . . . . . . . . . . 539 Chapter 19฀ •฀ Using Spatial Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 569 Chapter 20฀ •฀ Service-Oriented Architecture and the Service Broker . . . . . . . . . . . . . 595 Chapter 21฀ •฀ Full-Text Search Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 623

Appendices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653 Appendix A฀ •฀ The Bottom Line. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 655 Appendix B฀ •฀ SQL Server Analysis Services Overview . . . . . . . . . . . . . . . . . . . . . . . . 693 Appendix C฀ •฀ SQL Server 2008 Reporting Services. . . . . . . . . . . . . . . . . . . . . . . . . . . . 709 Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723

Contents Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .xxiii

Chapter 1  •  Overview of Microsoft SQL Server 2008. . . . . . . . . . . . . . . . . . . . . . . 1 SQL Server in the Enterprise World . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1 The Need for an Enterprise System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2 SQL Server Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 SQL Server’s Place Within Microsoft Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 SQL Server Licensing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 Installing SQL Server 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 Defining an Installation Plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10 SQL Server 2008 Installation Requirements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16 The SQL Server Installation Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17 Verifying the Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26 The SQL Server Tool Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 The Microsoft Client Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 Third-Party Tools and Utilities. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32 The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

Chapter 2  •  Understanding SQL Server Architecture . . . . . . . . . . . . . . . . . . . .35 Essential Internals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Server Data Storage Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Data Engine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Server and Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The SQL Server System Catalog. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The System Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . System Tables, Views, and Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . System Stored Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Datatyping. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . System-Defined Datatypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . User-Defined Datatypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

35 35 44 47 48 48 49 55 57 57 60 63

Chapter 3  •  Databases, Files, and Resource Management . . . . . . . . . . . . . . . .65 Planning a Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Planning for Database Usage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Planning for Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Capacity Planning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

65 65 66 68

XIV

| CONTENTS Creating Databases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating the Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Manipulating Database Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managing Databases, Files, and Filegroups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Altering a Database . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Growing and Shrinking Databases and Files . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Database Snapshots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

69 70 75 78 78 82 86 88

Chapter 4  •  Tables and CRUD Operations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .89 Designing Data Storage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89 Implementing a Normalized Design. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90 Denormalization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94 Creating and Dropping SQL Server Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 The Basics of Table Creation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 Computed Columns in Tables. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 Dropping Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 Table Partitioning . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100 Selecting Data from a Table . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105 Aggregation and Grouping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106 Joins and Table Correlation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109 Subqueries, Derived, and Temporary Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113 Common Table Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 Modifying Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 The INSERT Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122 The DELETE Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124 The UPDATE Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126 The MERGE Process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127 Using the OUTPUT Clause . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129 The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

Chapter 5  •  Procedural Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133 Procedural Structures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Batches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Control-of-Flow Statements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Error Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Basic Transaction Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Stored Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Designing Effective Stored Procedures. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating and Executing a Simple Stored Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . Using Parameters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managing Return Values. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Why Use Views? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Standard Views . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

133 133 135 136 138 142 144 145 146 147 151 151 153 154 154

CONTENTS

User-Defined Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Functions Versus Stored Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Built-In Functions Revisited . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Scalar Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Table-Valued Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using Synonyms. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Why Use Synonyms? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Synonym . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

|

155 156 157 157 159 161 161 161 162

Chapter 6  •  Managing Data Integrity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163 Understanding Data Integrity Controls . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enforcing Data Integrity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Data Integrity Categories. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Working with Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Primary Key and Unique Constraints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Foreign Key Constraints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Default Definitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Check Constraints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Working with DML Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Triggers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using AFTER Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using INSTEAD OF Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Special Considerations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rule and Default Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Default Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Rules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

163 164 164 165 165 168 172 174 175 176 179 183 185 186 186 187 187

Chapter 7  •  SQL Server and XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Returning XML from SQL Server Using FOR XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189 Creating XML with RAW Mode Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190 Creating XML with AUTO Mode Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192 Creating XML with EXPLICIT Mode Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 195 Creating XML with PATH Mode Queries. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198 The xml Datatype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200 Implementing the xml Datatype . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201 Shredding XML Data to Relational Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203 Validating XML with Schemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205 Using the XML Schema Collection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206 Using Namespaces in Schemas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207 Implementing XQuery. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Simple XQuery Expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208 Structuring Complex XQuery Syntax . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209 Creating an XML Structure with XQuery. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211 XQuery and Namespaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212 Other XML Datatype Methods. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

XV

XVI

| CONTENTS XML Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218 The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

Chapter 8  •  Managing User Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .223 The SQL Server Security Infrastructure. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Server 2008 Security Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing SQL Server Principals and Authentication . . . . . . . . . . . . . . . . . . . . . . . Implementing Logins. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing Users . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing Roles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing Permissions in SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Permission Behavior. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Setting Permissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ownership Chains . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

223 224 231 231 237 239 242 243 244 249 250

Chapter 9  •  Data Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .253 Transaction Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Database Recovery Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Internals of Transaction Logging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . How Transaction Logging Is Used. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup and Restore Strategies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Recovery Models and Backup Strategy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup Types. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing Backups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Full Backups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup Devices, Media Sets, and Media Families . . . . . . . . . . . . . . . . . . . . . . . . . . . Differential Backups. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Transaction Log Backups. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Partial Backups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Backups Using Management Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing Restores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Retrieving Backup Metadata. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing a Complete Restore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing Point in Time Recovery. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing a File or Filegroup Restore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Performing Page Restore Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using SQL Server Management Studio to Restore a Database . . . . . . . . . . . . . . . . . Other Issues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . System Database Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup Performance and Optimization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backup Compression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

253 254 254 255 257 258 260 260 261 261 263 264 264 265 267 267 268 271 273 275 275 277 277 279 280 280 281

CONTENTS

|

Chapter 10  •  Monitoring SQL Server Activity . . . . . . . . . . . . . . . . . . . . . . . . .283 Using System Monitor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Basic Monitoring Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Graphs, Logs, and Alerts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Selecting Resources and Counters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using SQL Profiler & Trace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Designing a Good Trace. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Selecting Data Columns and Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Evaluating Trace Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replaying Traces for Performance Analysis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DDL Triggers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . DDL Triggers Versus DML Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Trigger Events . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . EVENTDATA and Its Schema . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Event Notifications. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Event Notifications Versus DDL Triggers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Event Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing Event Notifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

283 284 286 287 290 290 291 297 301 305 306 307 311 314 315 315 315 317

Chapter 11  •  Using the SQL Server Agent Service . . . . . . . . . . . . . . . . . . . . . . 319 SQL Agent and Automation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Reducing Administration Overhead . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The SQL Server Agent Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Configuring the SQL Agent Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Jobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Jobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Job Steps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Schedules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Executing Jobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Alerts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Monitoring the Event Log . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Responding to Performance Alerts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding WMI Alerts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Operators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Operator Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Configuring Operators. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Associating Operators with Jobs and Alerts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Scripting the SQL Agent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding the SQL Agent System Stored Procedures . . . . . . . . . . . . . . . . . . . . Scripting Existing Jobs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

319 319 320 323 328 328 330 335 336 337 338 340 340 341 341 342 343 344 344 345 347

XVII

XVIII

| CONTENTS Chapter 12  •  Data Availability and Distribution . . . . . . . . . . . . . . . . . . . . . . .349 Overview of SQL Server Availability and Distribution Options . . . . . . . . . . . . . . . . . . Hardware Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Server Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Database Log Shipping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Configuring Log Shipping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Failing Over in a Log Shipping Scenario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Database Mirroring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Configuring Database Mirroring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Exploring the Mirroring Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replication. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Replication Overview. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Configuring Replication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

349 350 352 355 356 365 366 366 373 374 374 376 386

Chapter 13  •  SQL Server Data Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .389 Understanding the SQL Server Key Infrastructure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The SQL Server Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Extensible Key Management. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Backing Up the Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using Transparent Data Encryption . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Keys and Certificates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encrypting Data Using SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Authenticators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encryption with Passphrases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encryption with Symmetric Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encryption with Asymmetric Keys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Encryption with Certificates . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Module Signing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

389 390 399 400 401 402 403 404 404 405 406 408 411 413

Chapter 14  •  Indexing Strategies for Query Optimization . . . . . . . . . . . . . . . 415 Index Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Index Basics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Data Heaps. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Clustered Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Nonclustered Indexes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Planning Clustered and Nonclustered Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating and Managing Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Indexes with SSMS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managing Indexes and Fragmentation with SSMS . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating and Managing Indexes with TSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Special Index Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Covering a Query . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Logical Operator Processing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

415 416 418 422 424 426 430 430 432 436 439 439 440 441

CONTENTS

|

Chapter 15  •  Transactions and Locking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .443 The SQL Server Locking Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . What Gets Locked. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Types of Locks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Controlling Locks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managing Deadlocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Transaction Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Server Transaction Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing Explicit Transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using Savepoints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Transactions and Errors. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Concurrency and Performance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Distributed Transactions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Distributed Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Defining Distributed Transactions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Getting Transaction and Locking Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using the Activity Monitor Utility. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using Transact-SQL to Monitor Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

443 444 446 448 452 453 453 454 456 458 459 460 461 466 468 468 469 471

Chapter 16  •  Using the Resource Governor and Policy-Based Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .473 The Resource Governor. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Workload Groups . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Resource Pools. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Policy-Based Management . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Policy-Based Management Components. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating and Evaluating Policies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

473 475 478 482 483 491 501

Chapter 17  •  SQL Server and the .NET Client . . . . . . . . . . . . . . . . . . . . . . . . . .503 Understanding ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Making the Connection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Defining the Command . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Connected Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Disconnected Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Special Operations in ADO.NET . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Multiple Active Result Sets (MARS) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using SQLBulkCopy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SQL Query Notifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Introducing Language Integrated Query (LINQ). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Different Flavors of LINQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINQ to SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The SQL Server Implications of LINQ to SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . LINQ and the Entity Framework. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating and Querying the Entity Data Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The SQL Server Implications of the Entity Framework . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

503 505 507 509 512 515 515 516 518 522 523 524 528 530 531 533 536

XIX

XX

| CONTENTS Chapter 18  •  SQL Server and the Common Language Runtime . . . . . . . . . . .539 CLR Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . CLR Terminology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Enabling the CLR . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Managed Objects in SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Setting Up the Project Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Managed Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Managed Stored Procedures . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Create Managed Datatypes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deploying Managed Objects in SQL Server . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Assemblies. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Managed Objects . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managing CLR Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Managed Objects and User Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Assemblies and Code Access Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Security Considerations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

539 540 541 542 543 545 550 553 555 555 559 562 562 563 567 568

Chapter 19  •  Using Spatial Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .569 Spatial Data Concepts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Foundation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Geometry Versus Geography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Shapes Supported by Spatial Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Defining Spatial Storage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing the Geometry Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Loading Geometry Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Working with Points and MultiPoints. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Working with LineStrings and MultiLineStrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . Working with Polygons and MultiPolygons. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Using the GeometryCollection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing the Geography Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding the Spatial Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Geometry Versus Geography . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spatial Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Spatial Index Architecture and Restrictions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Spatial Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

569 569 571 572 574 575 575 577 579 581 584 584 584 586 587 588 589 592

Chapter 20  •  Service-Oriented Architecture and the Service Broker . . . . . . .595 The Essentials of Service-Oriented Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . SOA Distilled. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Service Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding the Service Broker . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Service Broker Terminology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Service Broker Workflow Scenario. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

595 595 599 602 602 604

CONTENTS

Implementing Service Broker. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Service Broker Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Constructing a Service Broker Dialog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

|

607 607 614 620

Chapter 21  •  Full-Text Search Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .623 Full-Text Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Full-Text Terminology . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Architecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Full-Text Indexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Stoplists . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Full-Text Catalog . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Full-Text Indexes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Writing Full-Text Queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing the CONTAINS Predicate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing the FREETEXT Predicate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Implementing the Full-Text Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

623 623 625 627 628 632 635 643 644 648 648 651

Appendices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 653 Appendix A  •  The Bottom Line . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .655 Chapter 1: Overview of Microsoft SQL Server 2008 . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 2: Understanding SQL Server Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 3: Databases, Files, and Resource Management. . . . . . . . . . . . . . . . . . . . . . . . . Chapter 4: Tables and CRUD Operations. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 5: Procedural Programming . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 6: Managing Data Integrity. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 7: SQL Server and XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 8: Managing User Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 9: Data Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 10: Monitoring SQL Server Activity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 11: Using the SQL Server Agent Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 12: Data Availability and Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 13: SQL Server Data Security . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 14: Indexing Strategies for Query Optimization . . . . . . . . . . . . . . . . . . . . . . . . Chapter 15: Transactions and Locking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 16: Using the Resource Governor and Policy-Based Management . . . . . . . . . Chapter 17: SQL Server and the .NET Client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 18: SQL Server and the Common Language Runtime . . . . . . . . . . . . . . . . . . . Chapter 19: Using Spatial Data . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Chapter 20: Service-Oriented Architecture and the Service Broker . . . . . . . . . . . . . . . Chapter 21: Full-Text Search Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

655 657 659 660 662 663 664 666 668 671 672 673 675 676 678 680 680 683 685 687 690

XXI

XXII

| CONTENTS Appendix B  •  SQL Server Analysis Services Overview . . . . . . . . . . . . . . . . . . .693 Designing the Data Warehouse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Data Warehouse Defined. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Dimensional Data Models . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Understanding Analysis Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating Data Cubes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Data Source. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Data Source View . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Dimension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deploying the Project. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Cube. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Browsing a Cube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

693 694 694 696 697 698 700 701 703 704 707

Appendix C  •  SQL Server 2008 Reporting Services . . . . . . . . . . . . . . . . . . . . . .709 Configuring Reporting Services . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Starting and Locating Reporting Services Ports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Loading the Report Manager . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Simple Report . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Defining the Report Project. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Data Source. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Creating a Report . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Designing the Report . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Deploying the Report . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

709 710 711 712 712 713 715 717 719

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723

Introduction Database technology is constantly evolving. The interplay among major database vendors such as Microsoft and Oracle, as well as the inevitable pressure of the open-source community, has demanded that database systems continue to push forward in both features and scalability. This fact means that the everyday database professional is constantly in a “catch up” mode. This book is an attempt to simplify that process by distilling the flood of information available. The very nature of a book like this, where the subject matter is so broad, is to ensure that the important points get included, but we can’t possibly include everything that SQL Server 2008 supports. In fact, the authors had numerous long conversations, not about what we had to put into the book, but the trade-offs of what we had to leave out. We tried to find a balance, providing at least general coverage of the most important topics. This meant that we had to sacrifice the “deep dive” in some situations to ensure that we could address as much as possible without overloading the reader. The other victim to this approach was an extensive coverage of the basics. Although we have included some introductory material, we had to make the assumption that this is not the first SQL Server book that you, the reader, have ever picked up. Although this is not an upgrader’s guide, it does assume that you have had some prior experience with SQL Server and are looking to get a firm understanding about the capabilities and mechanics of the tool. We also put a focus on addressing the important new features as much as we could, so that you can quickly add these to your toolbelt. Hopefully, we have hit the mark we were aiming for. We have also attempted to create a work that could be valuable as a reference as well as being read from cover to cover. The chapters address major topic areas so you should be able to drill into the information that you need. This book can, therefore, act as a roadmap, but we would encourage you to consult the SQL Server Books Online as well. There is a wealth of information there and some good code examples. Finally, we hope that this book will be an easy and entertaining read. Our biggest complaint about technical books over the years is that they are far too sterile and take themselves too seriously. We have been teaching this stuff for years and have found that you can’t take yourself or the subject matter too seriously if you want to engage your audience, so enjoy. We have had a wonderful time putting this together for you.

Who Should Read This Book Our target audience is the database professional with some SQL Server experience who is either: •u฀ Trying to ramp up skills on SQL Server 2008, or •u฀ Transitioning from another RDBMS to SQL Server

XXIV

| INTRODUCTION If you have read through the Microsoft marketing materials on SQL Server 2008 and would like to see what is under the hype, then this book is for you. Also, if you have some experience with database systems and SQL Server and you are ready to take your skills to the next step, this might also be a good match. We have tried to include information for both the SQL Server developer and administrator. In some organizations, these two roles are separate and distinct. In others, the same individual or team fills both roles. No matter what your perspective, you will find content related to your work. This does mean, however, that some of the chapters may be more meaningful than others. Although there is some information in this book related to client programming, this is not a book on ADO.NET. We have included an overview of client programming, including the Entity Framework and LINQ, but have done so from the perspective of the SQL Server professional, not the client developer. A client developer who needs to become more familiar with the dataserver tier might well find the discussion helpful, however.

The Mastering Series The Mastering series from Sybex provides outstanding instruction for readers with intermediate and advanced skills, in the form of top-notch training and development for those already working in their field and clear, serious education for those aspiring to become pros. Every Mastering book features: •u฀ The Sybex “by professionals for professionals” commitment. Mastering authors are them-

selves practitioners, with plenty of credentials in their areas of specialty. •u฀ A practical perspective for a reader who already knows the basics—someone who needs

solutions, not a primer. •u฀ Real-World Scenarios, ranging from case studies to interviews, that show how the tool,

technique, or knowledge presented is applied in actual practice. •u฀ Skill-based instruction, with chapters organized around real tasks rather than abstract

concepts or subjects. •u฀ Self-review test “Master It” problems and questions, so you can be certain you’re equipped

to do the job right.

What Is Covered in This Book Mastering SQL Server 2008 is organized to provide you with the following information: Chapter 1: Overview of Microsoft SQL Server 2008 is a general introduction to SQL Server, its features, and the installation process. Chapter 2: Understanding SQL Server Architecture contains an overview of the architecture of SQL Server with the intent of using this information to better control and optimize SQL Server performance. Chapter 3: Databases, Files, and Resource Management discusses creating and maintaining databases and filegroups, including the new FILESTREAM feature.

INTRODUCTION

|

Chapter 4: Tables and CRUD Operations covers table DDL and an overview of standard data modification statements, including the new MERGE keyword supported in SQL Server 2008. Chapter 5: Procedural Programming addresses creating views, stored procedures, userdefined functions, and synonyms. Chapter 6: Managing Data Integrity explains the options for managing data integrity in a database, and covers constraints and DML triggers. Chapter 7: SQL Server and XML addresses the integration of XML technology into SQL Server and provides coverage of the toolset that manipulates XML data inside the SQL Server environment. Chapter 8: Managing User Security explains the security structure built into SQL Server and provides instructions on how to implement this system to secure your data resources. Chapter 9: Data Recovery covers the transaction architecture of SQL Server, as well as the supported backup and restore operations available, including new features such as backup compression. Chapter 10: Monitoring SQL Server Activity explains the various tools available for monitoring different types of SQL Server activity, including performance counters, SQL Profiler, DDL triggers, and event notifications. An introduction to the Performance Data Warehouse/ Data Collector feature of SQL Server 2008 is also covered. Chapter 11: Using the SQL Server Agent Service addresses creating jobs, alerts, and operators using the SQL Server Agent service. Chapter 12: Data Availability and Distribution covers the different options that you have for moving data throughout your enterprise and making data reliably available to data consumers. Chapter 13: SQL Server Data Security shows the encryption and key management features of SQL Server 2008 including certificates, symmetric keys, and asymmetric keys. This chapter also covers the new Transparent Data Encryption feature of SQL Server 2008. Chapter 14: Indexing Strategies for Query Optimization discusses the workings of the query optimizer and explains how to create index architectures that will provide the highest level of benefit at the lowest maintenance cost. Chapter 15: Transactions and Locking provides an overview of the SQL Server locking architecture and explains its interaction with transaction processing. An overview of transaction management is also provided. Chapter 16: Using the Resource Governor and Policy-Based Management introduces two new features of SQL Server 2008 that allow detailed resource management of different types of workloads, as well as a new method for defining, evaluating, and enforcing nearly every aspect of SQL Server configuration through the use of policies. Chapter 17: SQL Server and the .NET Client offers the reader a SQL Server professional’s perspective on client programming, including traditional ADO.NET development, LINQ, and the entity framework.

XXV

XXVI

| INTRODUCTION Chapter 18: SQL Server and the Common Language Runtime explains the integration of the .NET Common Language Runtime in SQL Server and provides examples of implementing CLR objects in SQL Server applications. Chapter 19: Using Spatial Data addresses the new geometry and geography datatypes in SQL Server 2008 and provides examples of their use and relevance in today’s organizations. Chapter 20: Service-Oriented Architecture and the Service Broker gives the reader an overview of service-oriented architecture and shows how the SQL Server Service Broker can provide asynchronous services to the enterprise. Chapter 21: Full-Text Search Services illustrates the process of implementing a text search infrastructure in SQL Server using full-text indexes and queries designed to target those indexes. Appendix A: The Bottom Line Gathers together all the Master It problems from every chapter and provides a solution for each. Appendix B: SQL Server Analysis Services Overview provides a high-level overview of the data warehousing and multidimensional tools in SQL Server 2008. Appendix C: SQL Server Reporting Services Overview provides a high-level overview of the business intelligence reporting tools included in SQL Server 2008.

How to Contact the Authors We welcome feedback from you about this book or about books you’d like to see from us in the future. You can reach us by using the following email addresses: Michael Lee: [email protected] Gentry Bieker: [email protected] Sybex strives to keep you supplied with the latest tools and information you need for your work. Please check their website at www.sybex.com, where we’ll post additional content and updates that supplement this book if the need arises. Enter the book’s ISBN—9780470289044— and click Go to get to the book’s update page.

Chapter 1

Overview of Microsoft SQL Server 2008 SQL Server 2008 is a very complex product. It definitely deserves a little bit of introduction. Even if you have been working with SQL Server for quite some time, you might find some new features and nuances in the product that may catch you off guard, but they might delight you as well. In this chapter, we will focus on where SQL Server fits into the grand scheme of Microsoft architecture as well as its placement in your own computing enterprise. In this chapter, you will learn to: •u฀ Use Architect SQL Server services in the typical IT environment •u฀ Install SQL Server 2008 •u฀ Use the Microsoft SQL Server toolset •u฀ Implement other useful third-party tools

SQL Server in the Enterprise World The authors of this book have been working with SQL Server for over a combined 28 years. Back in the early days, it was a struggle to defend the product. We came to SQL Server with the same background as many other PC developers of our age, having worked with Clipper, Access, and other similar products. But SQL Server was different, and it required a change of perspective from the older tools with which we worked. Because Mike had worked for IBM, he had some previous experience with mainframes. Both Mike and Gentry also did some work with Oracle. However, SQL Server was definitely new territory compared to some of these older tools. We quickly discovered, by playing with the product and trying to put it through its paces, that SQL Server had a lot of potential, but it still had a long way to go. Part of the problem was developer education. Many of the problems that we came across were the result of developers trying to build applications with SQL Server using the same mindset and techniques that served them well during the Clipper days. Obviously, SQL Server was not Clipper. Some things had to change. SQL Server 2008 has come a very long way since those days when we first started to kick the tires, but one thing has not changed: the need to understand the big picture. SQL Server is a “big picture” product. Somewhat like an aspen grove where all of the trees share a common root system, SQL Server is integrated tightly with many other services and layers in the typical Microsoft-based IT environment. It is not strictly for storing user data any more. The sooner you grasp that, the better you will understand the logic behind the product, its architecture, and the direction that Microsoft is going with SQL Server.

2

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

The Need for an Enterprise System Most people reading this book should have some prior experience with SQL Server. To that end, we do not need to explain the rationale for enterprise data access. Our data is the lifeblood of our business. Some of the authors’ work has been done in heavily regulated industries such as insurance and casino gaming. In those environments, the need for data archival, the types of reports produced, and other data requirements are often dictated by governmental and other regulatory bodies. Without the data and programmatic resources to support those requirements, the organization cannot function. As we stated previously, in the early days of SQL Server, it was somewhat difficult to defend it as a truly enterprise product, but starting with the 2005 release, SQL Server started to challenge that perception. The key, though, is to effectively match your business’s enterprise-level requirements with the features that SQL Server brings to the table. The job is always easier if you are using the right tool. Some of the typical enterprise data requirements of an organization include: Interoperability In many cases, SQL Server data must be available to applications outside of your Microsoft Windows infrastructure. With the strong presence of mainframe systems, UNIX and Linux environments, Java platforms, etc., data interoperability requirements may be extensive. Performance Performance often means different things to different people. To the end user, it is typically about how fast they can get their data. For an administrator, the primary concern is maximizing overall throughput. These are often conflicting goals, and the database system must be able to balance them. Security The integrity of your data is only as good as your ability to secure it, but security these days goes beyond the typical authentication/authorization issues of the past. We must also be able to manage encryption processes, backup security, etc., while at the same time being proactive to prevent the security exposures of tomorrow. High Availability What good is having the data if it is not available to the people who need it when they need it? A good enterprise framework must ensure that we have adequate redundancy and the means to minimize downtime. Every second that the data system is not available can mean lost revenue, and in some cases, legal repercussions. Automation The more complex and larger a system becomes, the more important it is to be able to automate routine tasks and proactive maintenance to ensure that data availability and integrity is maintained. Otherwise, the typical database administrator (DBA) will be completely overwhelmed with day to day maintenance. Centralized Reporting Storing data isn’t much use if you can’t get data out when you need it in the formats that you need. A number of reporting environments are available. Whichever one you use, it is essential that the reporting tier be efficient, be flexible, and have the lowest possible footprint in terms of resource consumption. This is a pretty short list. Off the top of your head, you could probably double this list right now. In order to be of any real value, a database system must be “enterprise ready” and not just a data engine with a collection of unrelated supporting services. That won’t work in today’s IT environment. So, if SQL Server 2008 is our enterprise solution, how does it address these and other issues?

SQL SERVER IN THE ENTERPRISE WORLD

SQL Server Features All right, we know that this sounds like a marketing speech, but we really do have a rationale for covering features. It is important to have a good understanding of what a system can do if you want to design effective solutions. Besides, some of the features are new, and you have to have some justification for upgrading to the 2008 version when the accountants knock on your door.

SQL SERVER EDITIONS Be aware that much of this information is available electronically in SQL Server Books Online, either locally installed or web-based, as well as a variety of other good Internet and published resources. The goal here is to synthesize it for your convenience. You may want to check other online resources, though. Let’s begin by looking at the different editions of SQL Server 2008. SQL Server 2008 is available in a number of different versions. The primary distributions are the Standard and Enterprise editions. Additionally, Microsoft has release four specialized editions of SQL Server, namely Workgroup, Web, Compact, Developer, and Express. Each has its advantages and disadvantages. Because the Compact version specifically targets embedded systems, we will not discuss it here. All of the following editions come in 32-bit and 64-bit versions, although only Enterprise and Developer versions support IA64. SQL Server Express Edition •u฀ Intended for embeddable, lightweight, and standalone solutions •u฀ Supports one CPU •u฀ 1GB maximum addressable memory •u฀ 4GB maximum database size •u฀ Free download and distribution

SQL Server Workgroup Edition •u฀ Intended for small user loads, low-use web applications, etc. •u฀ Supports two CPUs •u฀ 4GB maximum addressable memory on 64-bit. OS Maximum on 32-bit •u฀ No maximum database size

Web Edition •u฀ Intended for larger traffic web applications •u฀ Supports four CPUs •u฀ OS maximum memory support

|

3

4

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

Standard Edition •u฀ Intended for most applications •u฀ Supports four CPUs •u฀ Memory up to OS maximum

Enterprise Edition •u฀ Provides the highest level of scalability and enterprise features •u฀ Unlimited CPUs to OS maximum •u฀ Memory up to OS maximum •u฀ Numerous enterprise features not found in the Standard Edition such as: •u฀ Database mirroring •u฀ Database snapshots •u฀ Online indexing •u฀ Online page restores •u฀ Distributed partitioned views •u฀ Numerous business intelligence (BI) features not found in the Standard Edition, such as: •u฀ Scale-out report servers •u฀ Infinite click-through reports •u฀ Text mining •u฀ OLAP dimension and cell writeback

Developer Edition •u฀ Functionally equivalent to Enterprise Edition •u฀ Licensed only for development environments, not to be used in production

Choosing the right edition is important. It needs to satisfy your current needs as well as your projected ones. You need to make sure that your database will support your performance and scalability requirements. You must also consider database size and the need for enterprise data and BI features.

SQL SERVER SERVICES AND FEATURES The feature list for SQL Server is extensive. Because we didn’t want to fill these pages with redundant information, we ask you to refer to the SQL Server Books Online. There you will be able to find a great deal of information regarding the essential and expanded features of SQL Server.

SQL SERVER IN THE ENTERPRISE WORLD

A few specific features are worth mentioning. These are the big ones. Not all of them will fit into your enterprise plan, but some may, and the fact that they all are bundled with SQL Server can be incredibly convenient and cost-effective. Support for Unstructured Data For the average database administrator (DBA), there are two kinds of data: the data in the database (structured data) and everything else (unstructured data). Unfortunately, most organizations have a significant amount of unstructured data that they must manage ranging from documents to pictures to proprietary data. Through FILESTREAM data, large binary data streams can be stored in the file system without sacrificing the transactional integrity of the database system. Policy-Based Management Policies make it easier to enforce best practices and standards. You can configure policies such as naming conventions, configuration standards, and coding standards. You can enforce these centrally for the entire organization. Not only does this simplify enforcement of standards, it also allows central modification of policies as needed. SQL Server Integration Services (SSIS) SQL Server Integration Services (SSIS) provide exchange/transform/load (ETL) functionality for SQL Server 2008. SQL 2005 took a significant step forward from DTS when it was released, providing not only more intuitive designers, but also a native .NET execution environment. SQL Server 2008 continues that process with significant pipeline scalability improvements as well as the ability to provide persistent lookups, which is a significant data warehousing enhancement. SQL Server Reporting Services (SSRS) Although not a new feature, this is, in our opinion, one of the most important enterprise features that SQL Server provides. The tight integration with SQL Server and the exposure of the reporting engine through a standard web services interface make Reporting Services one of the most compelling reporting solutions available for SQL Server 2008. Enterprise features such as web report distribution, subscriptions, and infinite click-through make this one feature you should definitely evaluate for inclusion in your enterprise data architecture. Full-Text Search Services Full-text indexing and special query syntax let you effectively search large text blocks for patterns, word forms, proximities, and other elements. SQL Server 2008 provides some compelling enhancements to the full-text set of services. They include features such as improved full-text index management and performance enhancements. If you haven’t at least played with Full-Text Search, you owe it to yourself to spend a few minutes getting cozy with it. Business Intelligence Business Intelligence (BI) content is critical to the success of SQL Server 2008. The BI agenda for SQL Server 2008 was very aggressive. One of the reasons that the schedule slipped for SQL Server 2008 was that the BI features needed a bit more polishing. The cornerstone of this version’s BI functionality is SQL Server Analysis Services. Supporting data warehousing through multidimensional data models (data cubes), Analysis Services provides mechanisms for analyzing and mining the large data volumes that most organizations have collected over the years. It is also highly integrated with other services, relying on SSIS for warehouse loading and SSRS for reporting on multidimensional data, including ad hoc reporting through the report builder.

|

5

6

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

This is another list that we could extend significantly, but our objective here was to give you a taste for the services available in SQL Server 2008, show you where some of the major enhancements fit, and provide a better framework for your own investigation and research. We strongly recommend that you take the time to review the SQL Server 2008 feature documentation in the SQL Server Books Online. As a system architect, you will not be able to design components into your system if you do not know what is available and how it works.

SQL Server’s Place Within Microsoft Architecture To say that Microsoft’s enterprise strategy relies on SQL Server is an understatement. Many of the products in Microsoft’s enterprise line are dependent on, or have significant integration with, SQL Server at some level. Data services are required everywhere, and SQL Server is the glue that holds many of them together. Among the Microsoft products with SQL Server dependencies or integrations are •u฀ Team Foundation Server •u฀ Systems Management Server/System Center Configuration Manager •u฀ Office SharePoint Server •u฀ Office Project Server •u฀ Operations Manager Server •u฀ BizTalk Server •u฀ ADO.NET

The logic is sound. Microsoft has already created a very compelling data engine, and when you need data services, there is no sense in reinventing the wheel. Of course, different tools require different levels of service support. For example, it is very common for SharePoint Server to be installed with SQL Server Express Edition, but a utility like Team Foundation Server might require real enterprise scalability. We added the ADO.NET to this list, and at first glance it might seem a little out of place. The rest of the elements listed are Server components, but ADO.NET is a .NET API, used to provide data access support for .NET applications. We’ve included it because although ADO.NET can provide connectivity to a wide variety of different database systems through their own .NET Data Providers, the SQL Server Native Client is specifically and tightly integrated with the ADO. NET API itself, providing API-level support for features such as SQL notifications and automatic failover with database mirroring. The lesson to learn from this discussion on Microsoft integration, however, is that sometimes it’s a good idea to expand our definition of what we consider “data services.” Especially now that to SQL Server 2008 supports unstructured data, the SQL Server Data Engine may play an ever more expansive role whenever and wherever any data is needed in any format and for any purpose. If we remember that and learn to take full advantage of the services that SQL Server provides, we will be able to design more comprehensive architectures, comfortable that SQL Server will provide data services at any level necessary, from embedded to enterprise.

SQL SERVER IN THE ENTERPRISE WORLD

SQL Server Integration with Team Foundation Server One of the most extreme real-world examples of SQL Server integration in the Microsoft Architecture is Team Foundation Server. This is a perfect case study in the prevalence of data and how SQL Server can provide data services whenever and wherever they are needed. When author Mike Lee teaches classes on Team Foundation Server, he frequently uses a diagram similar to the one shown here to illustrate the architecture of Team Foundation Server. Note the extensive use of SQL Server services in the diagram. Team Systems Clients

Team Portal Windows SharePoint Services ASP.NET SQL Server Reporting Services Foundation Server Service Tier

Report Layer

SQL Server Work Items

Source Control

Methodology

Build Data

SQL Server Analysis Services Data Warehouse

To do its work, Team Foundation Server requires significant data services. Rather than provide the data tier as part of the Team Foundation Server product itself, the Foundation Server delegates all of its data requirements to various SQL Server services. Some of these are creative in their application. Work Items A Work Item in Foundation Server is essentially an assignment to complete a specific unit of work. When a project manager on a team needs work done, they create a Work Item in Foundation Server and assign it to the resource that is responsible for that item. These Work Items are database entries that document the work and its history. Source Control Repository Traditionally, source control storage has been file system based, but in Team Foundation Server, all source code and all historical versions of that code, along with their labeling, are stored in SQL Server tables. This makes source control significantly more scalable and stable in other environments such as Visual Source Safe.

|

7

8

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

Methodology Data An important part of Team Foundation Server is its support for development methodologies such as Agile. The choice of methodology affects many factors in the system, such as the types of Work Items, reports, and process guidance documentation. Methodologies are also highly customizable and an organization can create their own methodologies. The is methodology data is imported into SQL Server through Foundation Server and stored there for any future team projects to reference. Build Data Another feature of Foundation Server is support for Team Build processes. Repeatable builds are an important part of the application development lifecycle. They ensure that all builds are consistent and use the same configurations. To this end, historical build information must be retained so that a build administrator and/or release engineer can track what happened in each build. Data Warehouse All of the operational data in the Work Items database, the Build Database, and the versioning information in the Source Control Repository are used for progress and status reporting. SQL Agent Jobs are used to periodically aggregate data cubes running in SQL Server Analysis Services, thus providing reporting capabilities directly from the warehouse. You must have Analysis Services installed in order to install Foundation Server because it handles all data processing for reporting. Report Tier Using SQL Server Reporting Services, the report tier provides reports that interact with the data warehouse, providing information regarding schedules, budgeting, volatility, code churn, etc. Many built-in reports are available, depending on which methodology you use, but custom reports are also common, providing additional custom information regarding timelines and processes. Looking at the Team Foundation Server architecture can teach us a very important lesson. SQL Server has the capacity to do so much if we let it do its job! Sometimes we are so focused on using SQL Server as a user data repository that we forget its role as an extremely valid cog in the overall architecture. SQL Server’s ability to expose functionality through service endpoints is just one feature that makes it highly interoperable.

SQL Server Licensing Many readers will not have to deal with licensing issues, because those choices are out of your hands, but for those of you who are small business owners or consultants, we’ll say a few words on SQL Server licensing options.

What Do We Know? At this writing, we do not have the specifics on SQL Server 2008 licensing. However, we have been promised that the price will not increase from SQL 2005 licensing costs. The following guidelines are based on 2005 licensing schemes and should be reviewed prior to publication.

SQL SERVER IN THE ENTERPRISE WORLD

SQL Server licensing costs and options typically depend on which edition you use. The good news is that Microsoft has stated that it does not plan to increase licensing costs for SQL Server 2008, so your costs should be similar to those for SQL Server 2005, assuming that you are planning to use comparable editions and licensing options. The other bit of good news on licensing is that the Express edition is still free. There is, of course, a license agreement, and you cannot take advantage of free distribution of the Express edition unless you register with Microsoft and agree to its licensing terms for distributing the Express edition with your products. The Compact edition, typically used for handheld devices and embedded solutions, also falls into this category. The Developer edition of SQL Server is a little different in terms of licensing. This edition is feature-identical to Enterprise edition, but can only be licensed to an individual developer and used for development. No production server can use Developer edition. In earlier versions of SQL Server (those before SQL Server 2000), the Developer edition was performance- and connection-throttled, which prevented its effective use in production. This was problematic because it prevented the developer from doing reasonable stress testing, performance benchmarking, etc. Fortunately, the Developer edition is no longer throttled, and now it is an outstanding option for developing enterprise-capable applications at a reasonable cost. All other versions are licensed under one of three different options, as indicated in Table 1.1. The obvious conclusion is that the organization should choose the option that will satisfy their needs at the lowest licensing cost. The more feature-rich the edition, the higher the license fees in each category. For example, a single-processor license for the Workgroup edition would be less expensive than a single-processor license for Standard edition.

Table 1.1

SQL Server Licensing Options

Licensing Option

Description

Best Suited For

Per Processor

Each available processor must be licensed. If a processor in a server is configured to be inaccessible to SQL Server, it does not have to be licensed. Licensing is done per socket, not per core/Logical CPU.

High client to server ratios and Internet accessible applications.

Server plus Device CAL

Requires a license for each server, plus a CAL for each device accessing SQL Server within your organization.

Shared devices such as shared workstations or kiosks.

Server plus User CAL

Requires a license for each server, plus a CAL for each user accessing SQL Server within your organization.

Limited number of users needing access to the server, especially if they connect with multiple devices.

Of course, licensing costs will depend on who you are. Microsoft has a variety of licensing programs as well as negotiated costs for specific customers such as large corporations, governments, and educational institutions. For more information regarding specific licensing costs, you can check Microsoft’s website for current retail costs or contact your Microsoft Licensing Reseller for volume license information.

|

9

10

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

Installing SQL Server 2008 Now you should have a good feel for where SQL Server 2008 fits into the typical IT infrastructure. The next step is to look at the installation process. Like any good architecture, it all starts with a plan. When it comes to SQL Server installation, planning is key. You have a number of decisions to make when you perform an installation. It’s easier to do it right the first time than to try to modify it later.

Decide Now and Then Forever Hold Your Peace In one organization that Mike Lee consulted with, some decisions regarding character sets and collations were made very early. The organization decided not to go with the default settings, which is not inherently a problem as long as a user has a defendable reason for doing so. These decisions were made early in the organization’s existence. Over time, as the organization grew, it distributed databases to many customers and also used them internally. When the organization later decided to examine and reevaluate its installation decisions because the configuration had become cumbersome, it was too late to change those decisions because many customers as well as internal systems had become dependent on the initial configuration. Ironically, no one could say why the initial decision was made. The morale of this story is to make sure you have reasons for every design choice you make and be sure that you think well into the future.

Defining an Installation Plan Some of the choices that you must make are obvious. Which editions of SQL Server 2008 will you choose? What licensing schemes will you use? What kind of hardware should you purchase? These are some of the initial decisions. Some of your options are flexible: you can change your mind about them later if needed. For example, you can always add more memory or purchase additional Client Access Licenses (CALs). Things get trickier when you need to decide what the database architectures will look like. How many databases should you have? Are there performance implications to your decisions? What about partitioning? Should you install multiple instances of SQL Server on a single server? You can best answer these and similar questions by looking at your enterprise data needs. Let’s take a closer look at some of the major planning issues such as capacity planning, database consolidation and distribution, and archival requirements.

CAPACITY PLANNING When planning capacity, the professional DBA must consider the projected requirements of all the major resources that SQL Server will use. More specifically, SQL Server requires resources from four major categories. Think of them as SQL Server’s four basic food groups. A server must have adequate resources from each group to remain healthy. •u฀ Disk and I/O Subsystem •u฀ CPU •u฀ Memory •u฀ Network

INSTALLING SQL SERVER 2008

|

Just as the human body needs to balance grains and proteins in its diet, SQL Server needs to have an adequate balance of each of these resources to keep operating at its maximum potential. Any one of these resources out of balance can cause a resource starvation problem in another area. Capacity planning will be covered in more detail in Chapter 3, “Managing Databases, Files, and Filegroups,” so for now we will be content with a general overview. What are the important things to consider when preparing for a SQL Server installation?

Disk Resources Databases require disk space. Although a well-normalized database will have lower disk requirements than a denormalized one, there is still a significant disk need for any production system. Data warehousing might require significant disk resources, not only to handle the volume of gathered data, but also to perform the multidimensional data modeling that is typical to data warehousing. It is also essential that the I/O subsystem be able to keep up with requests to read and write to disk, or else the overall performance of the system will suffer. Disk storage requirements may depend on a number of factors. You have to consider the current data that the business needs to function, as well as archival requirements caused by regulatory concerns, data warehousing/mining strategies, encryption requirements, and data growth estimates. Some of these issues, specifically warehousing and archiving, may necessitate additional servers—not just more disk space. Data growth is one of the more complex issues. You not only need to consider how much data you have now, but also how much you will have in the future. There are three basic growth models, each of which has numerous variations. You can probably evaluate your growth patterns according to one or more of these models. Linear Growth This is the simplest growth model. It assumes that the database will grow at a constant rate over time. For example, assume 400MB database will grow at a constant rate of 50MB per month. One year from now, therefore, the database will be 1GB in size. Use the following formula to calculate linear growth: FDisk = CDisk + (GAmt × NPer) In this formula, use the following: FDisk = future disk space required CDisk = current disk space used GAmt = amount of disk growth per period NPer = number of periods Compound Growth This model assumes that the growth rate is based on a percentage growth rate rather than a fixed growth amount. As the size of the database increases, so will its future growth amount because each increment is a percentage of the current database size. A database of 100MB that grows 10 percent per year would be 110MB at the end of the first year, but 121MB at the end of the second year. Use the following formula to calculate compound growth: FDisk = CDisk × (1 + Rate) N In this formula, use the following: FDisk = future disk space required

11

12

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

CDisk = current disk space used Rate = percentage growth rate per period N = number of periods Compound Growth with Compounding Growth Rate This model assumes that as the database grows, so does the growth rate. For example, suppose that we expect the database to grow by 10 percent this year, but we expect that the growth rate itself will also increase every year by 20 percent. That means that next year, the growth rate will be 12 percent. The first year, therefore, a 100MB database will grow by 10MB. In this case, the 10MB is called the initial increment and the 20 percent is called the incremental rate of growth. Use the following formula to calculate this model: FDisk = CDisk + (Init × (1 – IncRate) (N+1) + (1 – IncRate) In this formula, use the following: FDisk = future disk space required CDisk = current disk space used N = number of periods Init = initial increment of growth IncRate = incremental rate of growth per period Of course, you must consider the I/O subsystem as well. Remember that at some point, any data that you might want to work with in your application must move from disk to memory. The speed at which this takes place will have a direct effect on the performance of your application. The specifics of monitoring and tuning resources will be covered in Chapter 10, “Monitoring SQL Server Activity,” and Chapter 16, “Using Resource Governor and Policy-Based Management,” respectively.

Processor Resources When planning processor architecture, you have two primary concerns: what type of processor and how many. The decisions that you make can determine not only the amount of raw power in terms of calculations per second, but also may determine the amount of addressable memory that is available to SQL Server. Because data normally must be in current memory to be used in SQL Server, the size of the data cache may be critical for application performance. First, for determining the number of processors, if you have an existing database that you can use to benchmark, you’re way ahead in the game. Specifically, you want to look at the number of users and how much data they will be using. Most queries are not really CPU bound, especially those that focus strictly on read and write activity, but if you have a lot of procedural logic, number crunching, aggregations, or a large number of users, you will need more CPU resources. When considering processors, you must also think about licensing costs. Remember that if you use a per-processor licensing scheme, each processor will have to be licensed. The processor affinity settings in SQL Server allow you to specify which processors SQL Server is allowed to use. When allocating processor resources to SQL Server, you must remember to allow sufficient resources for other services that might be running on the same server. You don’t want to allow a

INSTALLING SQL SERVER 2008

|

situation where SQL Server could be starving other services. Of course, this brings up the question of whether the SQL Servers are dedicated machines or share responsibilities for other services. This in turn will depend on projected server activity levels and the level of resource consumption. As you make these decisions, remember that processor licensing is per socket, not per core.

The Real Cost of Affinity Remember that the processor affinity settings in SQL Server are very tightly integrated with the licensing system. Make sure that you don’t use processor affinity settings that might violate your license agreements.

When deciding on processor architecture, you must also consider your memory requirements. Chapter 2, “Understanding SQL Server Architecture,” will cover the specifics of memory configuration and how memory is used, but for now, remember that the primary difference between 32-bit and 64-bit processors is the amount of memory that is addressable by the processor. The 32-bit world limits the server to 4GB addressable memory, only 2GB of which are available for SQL Server unless you use some special switches and creative manipulation. 64-bit processors significantly increase that limit. How much of an increase depends on the processor, but theoretically it could extend to 16 exabytes. This is a theoretical limit only, and all current 64-bit architectures implement limits that are a tiny fraction of this level, averaging around 32GB of addressable memory. The real story then is not that 64-bit processors are faster. In fact, dealing with a 64-bit address can actually cause a 64-bit processor to run slower than a comparable 32-bit processor. The real issues are the amount of memory that can be addressed and the convenience with which that memory can be addressed without special configuration on the part of the administrator.

Memory Resources In order for data to be of any use in your applications, in most cases it needs to be brought from disk into memory. The data in memory is SQL Server’s real-time view of the database. Data on disk is only as current as the last flush from cache to disk. Because data must be in memory to be useful, it takes a lot of memory to drive your application, and the more data you have to work with, the more memory you need. Just because you have large databases does not mean that you need a lot of memory. However, you should try to ensure that there is enough memory to store the commonly used data and that there is enough room to bring additional data into memory without having to constantly swap between cache and disk. Don’t forget that you also need memory for other resources such as user connections, open objects, stored procedures, and locks.

One Hand Washes the Other It should be obvious at this point how interdependent all of these resources are. For example, the CPU type will determine your memory architecture. The amount of memory can determine how much work the I/O subsystem will have to do. The more that you tinker with SQL Server, the more you will realize how closely related all these resources really are.

13

14

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

Network Resources Because the whole idea behind SQL Server, especially from the enterprise perspective, is to make data available to a broad audience of users, it is important that the data be able to get to its ultimate destination as efficiently as possible. A number of issues are at play. First of all, you need to make sure that your network is capable of handling the volume of data that you will need to push around. This means that you need to pay attention to things like network cards, switches, and cabling. You can only push so much data through a 10-megabit pipe. The other thing that you need to consider is how your applications are written and whether they are using network resources appropriately. For example, are you properly restricting your result sets so that you are not returning any more data to the client than they really need? You can limit some bandwidth by doing little things like turning NOCOUNT on in all of your stored procedures.

Doctor, It Hurts When I Do This Sometimes the easiest way to solve a performance problem is to say, “Don’t do that!” For example, I had a client that was having performance problems with an application that returned a large amount of sorted data to the client. The initial concern was that it was a network problem based on the volume of data that was being returned. It became clear after testing, however, that the problem was related to the amount of extra time that it took the server to do the sorting. Because many clients were requesting sorted data, the throughput was dragging. Because sorting does not reduce the amount of data that goes across the wire, this task could be relocated without increasing network consumption. We found that in this situation, the sorting could be offloaded to the client because there was excess capacity on the client that was not being used. Sometimes you have to be willing to accept that the server is not the best place to perform a task.

DATA CONSOLIDATION AND DISTRIBUTION Depending on how much data you have and how your enterprise’s users need to access that data, there may be varying ways to consolidate or distribute data and server resources. There can be significant advantages to each depending on your needs. Let’s begin with a discussion of server consolidation. As licensing costs and hardware costs can be high, it is very important to make sure that you get the most “bang for the buck.” Are you really using all of your resources to their fullest potential? It doesn’t make sense to spend extra money on servers and licenses if you are not fully utilizing what you have now. In addition to these issues, you might also benefit from a simplification of administrative processes, auditing requirements, and security management. Fewer boxes to baby-sit means fewer things that can break. Of course, the downside is that when things do break, it can have a much more serious impact on the organization. You might be introducing a single point of failure by performing a server consolidation. You also have to be careful not to overload your server resources. Consolidating to

INSTALLING SQL SERVER 2008

|

the point that there is no room for growth means that even small changes in the way that server resources are used can have significant effects on the overall performance of your servers. There are many ways to consolidate. Here are a few. Merge Databases One approach is to create a smaller number of larger databases. Fewer databases means that there are fewer administrative tasks, but these tasks may be more cumbersome and time-consuming. There may also be problems with increased transaction activity and loss of configuration granularity. Adding More Databases to a SQL Server Instance Although this can solve the problems inherent in managing very large databases, it still requires that all databases running under the given instance share all server-level configurations and address space. However, for administrative reasons, it may be desirable to have many databases running in a single instance. The benefit is that you only have to configure and tune that single instance. Installing Multiple Instances on a Single Server The primary benefit of having multiple instances is that they can be configured and tuned individually. If databases have different server configuration needs, they do not need to run on separate servers, but instead can run in separate instances. All instances still will share the same server resources, however, and any platform tuning will affect all instances. Using Server Virtualization Using a tool such as VMware or Microsoft Virtual Server allows multiple virtual or emulated “servers” to coexist on the same hardware. Each one can be configured separately, although they all will still share the same actual hardware resources. This approach can be very effective when you have excess hardware capacity, but requirements that specify individual OS configuration and security. No matter which consolidation approach you choose, remember that the ultimate goal is to make the best use of all of your hardware resources and licenses. If your consolidation scheme results in unwanted performance degradations or security compliance problems, you should rethink that strategy. Also, always remember to reserve enough capacity for reasonable growth, or you will quickly be required to start distributing some of your load. Generally, the advantages of consolidation are also the disadvantages of distribution. The reverse is also true. While consolidation can lower licensing and hardware costs, distribution increases them. Conversely, while distribution can increase performance by providing additional resources to your applications, consolidation can result in reduced performance because too few resources are spread across too many databases or instances.

ARCHIVAL REQUIREMENTS Another issue to consider when planning an enterprise installation strategy is archival requirements. Although your organization may have painstakingly collected mounds of data over the years, not every query that you execute has to wade through those mounds of data every single time. Good indexing strategies can help with the performance problems that arise when you query from very large data stores, but other problems can emerge such as the maintenance costs of those indexes, the need to back up large amounts of non-changing data just to capture a small amount of live data, and so on. If you can separate those large volumes of data into other repositories, whether different tables or entire archival databases, your queries will have to trudge through much less data to complete their tasks.

15

16

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

But What about the Warehouse? Although this would seem a good time to bring up the subject of data warehousing, the subject is far too vast for inclusion at this point. Appendix C, “Analysis Services Overview,” provides a very brief overview of SQL Server Analysis Services, which includes a general review of data warehousing concepts. However, the best place to start reading would be the work of Ralph Kimball and Bill Inmon, the true pioneers in this area. We specifically recommend the books in the Data Warehouse Toolkit series by Kimball and Building the Data Warehouse by Inmon, all published by Wiley. From those readings, you can decide which approach makes the most sense in your organization. Also remember that most organizations that do serious data warehousing in the real world are using a combination of theories based on the practical needs of the moment.

The first real issue when planning archival storage is to decide how to segment your data. Often, data is segmented based on date. Older data is archived while newer data is retained in the operational data store. There may be other ways in which your data should be segmented, however. Identifying the factors that differentiate current from archival data is the most important aspect of defining a successful archival strategy. Once you have decided how to segment the data, you need to decide the best archival storage approach. In some cases, you might simply archive data into separate tables in the same database. Other cases may require you to completely separate archived data on separate servers. There are many different techniques for supporting these archives including table partitioning, partitioned views, and rowset functions. For now, the important thing is to consider what the resource load will be, based on the amount of needed archival data and what kind of server installation strategy you will need to support it.

SQL Server 2008 Installation Requirements The official Microsoft SQL Server installation requirements are, to be polite, barely adequate. As you evaluate the true requirements for SQL Server, remember that SQL Server is a resource hog. It loves memory, can use a lot of disk space, and often requires a significant network pipe. That said, the requirements posted on Microsoft’s website are barely enough to get the service running, assuming that there are no other primary services running on the same machine. Table 1.2 lists the standard Microsoft-recommended requirements in abbreviated form. To get the complete listing, please consult the books online.

Table 1.2

Microsoft SQL Server Installation Requirements

Component

Requirement

Processor

64- or 32-bit (version dependent) processor at 1GHz or higher

.NET Framework

.NET 3.5 Framework SP1 (installed by the SQL Server installer)

Operating System

Windows Vista (any version)

Windows Server 2008

Windows Server 2003 SP2 Windows XP SP 2

INSTALLING SQL SERVER 2008

Table 1.2

Microsoft SQL Server Installation Requirements

|

(continued)

Visual Studio 2008

If VS 2008 is installed on the same machine as the server or client tools, it must be updated to SP1. It is not required to have VS 2008 installed in advance.

Other Software

Microsoft Internet Explorer 6 SP1 or higher Microsoft Windows Installer 3.1 or higher MDAC 2.8 SP1 or higher

Memory

1 GB or more

Hard Disk

280 MB - Complete Data Engine Core 90 MB - Complete Analysis Services 120 MB - Complete Reporting Services 120 MB - Complete Integration Services 850 MB - Complete Client Components 240 MB - Complete Books Online

Also be aware that many components will be installed by the SQL Server installer. In addition to the .NET Framework, there will be installations of MSXML support, SQL Native Client installation, and other components. During the installation process you will be asked to identify how the SQL Server services are going to log in to Windows. You should consider this requirement before you begin installation so you can either identify or create the necessary security accounts before the installation process begins. This should be part of your security planning. The choice that you make can have a significant impact on the ability of the installed server to effectively communicate with other SQL Servers and resources on the local machine and in the greater enterprise environment. The general recommendation is that you should create local or domain user accounts with the permissions necessary to perform the tasks required. Do not use the Network Service account for the Data Engine or SQL Agent services because this approach does not follow the “least privilege” principle, which states that you should only grant an account the minimum permissions necessary to perform the required task. If your SQL Server must communicate with other service to perform remote procedure calls, replication, using remote data sources, or similar tasks, you should use a domain user account rather than a local user account. If your server will access local resources only, the “local service” account may be adequate, because it has the same permissions as members of the local Users group.

The SQL Server Installation Process The SQL Server installation process is organized into three primary phases:

1. Compatibility Check 2. Data Gathering 3. Software Installation

17

18

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

COMPATIBILITY CHECK The first phase, Compatibility Check, allows the installer to verify that the hardware/software configuration of the target server meets all minimum requirements for installation. If any of these requirements are not met, the installation will be terminated and the problem must be rectified. It is best to review all of the requirements in advance and make sure that your server is properly configured before you begin. It will definitely make the installation process go more smoothly. The installation process is wizard-driven and should not be problematic if you have installed all of the required software in advance. On the main installation screen, select Installation from the menu on the left. This dialog is pictured in Figure 1.1.

Figure 1.1 The SQL Server 2008 Installation Center

Once you launch the installer, you will be asked to accept the license agreement and install the setup support files. These steps must be completed before the formal installation process can begin. The next screen in the installation process is the main installation control panel, pictured in Figure 1.2. From here you can perform a new installation, upgrade older servers to SQL Server 2008, or modify a SQL Server cluster. Click the first option to perform a new standalone installation. In a moment, a new popup window will appear to begin the formal installation. It will automatically perform a compatibility check and report the results in the next screen as shown in Figure 1.3. If your system does not pass the minimum compliance check, you will not be able to continue any further until you resolve the issues. There is a button on the screen labeled Show Details. Click this button to get more information regarding the results of the configuration check. Figure 1.3 shows the detailed information. When you are ready to move on, click the OK button.

INSTALLING SQL SERVER 2008

Figure 1.2 The SQL Server Installation panel

Figure 1.3 Viewing the compatibility results

|

19

20

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

DATA GATHERING At this point we enter the data-gathering phase of the installation. This begins with a licensing screen as pictured in Figure 1.4. You will see that you can either enter a key for a licensed version of SQL Server or select a free version such as an evaluation version. Make your selection and enter the key, if necessary. Then click Next to continue.

Figure 1.4 Validating the edition

The next screen is the license terms agreement. It is not pictured here for brevity. Simply accept the license agreement and click Next to continue. The next screen will provide the installation of the setup support files. You must perform this small installation before you can continue. Again, because this is a simple dialog, it is not illustrated. Just click the Install button to advance. When complete, the installer will provide a report like the one pictured in Figure 1.5. Check for errors, and make sure that warnings, like the one in this dialog, are verified before you continue. Click Next to advance. The next thing that the installer needs to know in this phase is which SQL Server 2008 services you want to install. SQL Server uses a unified installer, which is much more convenient than having separate installers for each service. In Figure 1.6, all options have been selected, but you can choose any combination of installed features that you like depending on your enterprise installation plan. Do not install components that you do not need because this will add additional administration requirements, could result in unnecessary resource consumption, and may be a security risk. Click Next to advance.

INSTALLING SQL SERVER 2008

Figure 1.5 The Setup Files Installation report

Figure 1.6 The Feature Selection dialog

|

21

22

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

The next page in the wizard, pictured in Figure 1.7, allows you to configure the instance. Is this a named instance or the default instance? Typically, the default instance will resolve to the NetBIOS name of the computer, which is convenient, but you can have only one default instance. If you are not sure what other instances of SQL Server you have installed, this dialog will list them at the bottom. Be sure to configure the correct location for file installation and the desired instance name before you continue. Select either the default instance or provide an instance name and click Next to advance.

Figure 1.7 Configuring the instance

The next screen summarizes the disk space requirements. Notice that in this example, all services have been installed and it requires over 2.5GB of disk space. Figure 1.8 provides this illustration. If you do not have sufficient disk space available, you will receive an error at this point. Click Next to advance. The next dialog, Server Configuration, allows you to configure all of the services in one location. Notice how this dialog, pictured in Figure 1.9, gives you the option of configuring service login accounts and passwords, as well as deciding the startup mode for each service. Now is the time for you to provide the login information for the accounts that you created in advance for the services. If you want, you can simplify the configuration by using a single account for all services and applying this account with one click. Choose the account wisely. The local system account can work fine if the SQL Server does not have to communicate with other services on the network, otherwise you may want to create a domain account with appropriate permissions. This will give you more control over the servicelevel security architecture. Notice also that the Collation tab allows for configuration of default collations for both the Database Engine and Analysis Services. Select your collations carefully and only depart from the defaults if there is a verifiable reason to do so. Although you can create artifacts in a database that

INSTALLING SQL SERVER 2008

depart from the default collations, the settings that you choose here will define a set of default rules that will be assumed to apply unless you create an exception. If there is an error condition in any of the configurations, the tab will appear with an error symbol. At the bottom of the screen, below the grid that defines the SQL Browser and Full Text Daemon Launcher, an error bar will appear. You must resolve these errors before continuing. Click Next to continue.

Figure 1.8 Disk space summary

Figure 1.9 The Server Configuration dialog

|

23

24

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

Now the installer will begin with the configuration of each individual service. First, you configure the Database Engine. This includes the security modes configuration as well as the file location and FILESTREAM configuration. On the first tab, specify the security mode. Windows Authentication mode uses the Windows identity of the logged-in user to authenticate that user to SQL Server; the Mixed mode option also allows SQL Server to authenticate users with its own internal authentication mechanism and login lists. We are using Windows Authentication mode. You can add yourself as an administrator by clicking the Add Current User button. Otherwise, the add button allows you to browse your accounts directory and add administrative users and groups to the server. You must add at least one administrative user before you will be allowed to continue. Figure 1.10 illustrates the Database Engine Configuration dialog.

Figure 1.10 The Database Engine Authentication Configuration dialog

If you are unsure of which mode you need, you may want to skip ahead to the discussion in Chapter 8, “Managing User Security,” and read up on the difference. This is a configuration that you can easily change after installation, however, so you are not stuck forever with the choice that you make here. If you do choose Mixed mode, you will have to define a password for the system administrative account, which is sa. Otherwise, you must add appropriate Windows users or groups as administrators in the bottom part of the dialog so that an administrator will be assigned. If you try to advance beyond this dialog without providing some sort of administrative access, you will get an error message that will prevent you from continuing. Also, don’t forget to look at the other tabs in the dialog, labeled Data Directories and FILESTREAM. The Data Directories tab allows you to define the default locations for all data paths in SQL Server. Although you can override most of these when working with your data, it is a good idea to plan your default locations based on your server resources and configurations.

INSTALLING SQL SERVER 2008

|

The FILESTREAM tab provides for the initial configuration of the FILESTREAM storage option in SQL Server. This feature allows you to define a share on the server that will store files that the data engine can stream to the user. This is an alternative to storing the file data directly in the database. The next dialog, Analysis Services Configuration, is very similar to Database Engine Configuration and works in the same manner. This dialog allows you to specify the security and file location setting for the Analysis Server. This screen is so similar to the previous one that it is not pictured here. The Reporting Service Configuration dialog is used to configure the deployment mode for SQL Server Reporting Services. You have a choice between Native and SharePoint modes. You can also install an unconfgured server. Make your selection in this dialog, pictured in Figure 1.11 and click Next to advance.

Figure 1.11 Configuring the reporting server

Native Mode Reporting Server Native mode allows the reporting server to act as a standalone application server, using IIS and ASP.NET features to handle all configuration, report access, security access, etc. This is the default option and does not require any additional software installed beyond IIS and the .NET Framework. SharePoint Mode Reporting Server In this mode, the report server is not standalone, but rather is part of a SharePoint application deployment. Reports can be stored in SharePoint libraries and accessed by users through the SharePoint interface. This affects the ability of users to access reports through a URL, because all access must be qualified within the SharePoint hierarchy. Also, appropriate versions of Windows SharePoint Services or Microsoft Office SharePoint Server must be installed to handle the Report Server deployment before the report server can be accessed.

25

26

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

The next dialog, Error and Usage Reporting, gives you the option of sending experience information to Microsoft. This is very simple and is not illustrated here. After this, you get one more report dialog, validating your choices and preparing the installation. As pictured in Figure 1.12, there should be no errors on this report or you will not be able to continue.

Figure 1.12 Final pre-installation report

The last data-gathering dialog (not pictured) presents you with a summary of your choices for your review. Make sure that the configurations listed match your intended installation before you continue. When you are ready, click the Install button to begin the actual installation.

SOFTWARE INSTALLATION Once you have verified your installation parameters and are ready to begin with the installation, click the Install button to begin the installation process. Installation time depends on the services that you have selected and the configuration of those services. Once the process is complete, all of the installation options should show Success. Clicking the Next button will take you to the final dialog, which will contain a link to the installation log. Make a note of the location of the installation log files. If there are any problems with the installation, you may want to review these logs to troubleshoot your problems.

Verifying the Installation If you did not get any errors when you ran the installation, you probably will not have any problems, but it is always a good idea to run some quick checks to make sure that everything happened the way you expected. Here is a list of some of the actions users typically take to verify an installation.

INSTALLING SQL SERVER 2008

|

Check for the Installed Services Using the tool of your choice, ensure that the services have been correctly installed, configured, and started. Figure 1.13 illustrates the Windows Services applet. Notice that each of the services is listed, along with its login account and current state. Ensure that all services will start as configured and alter any startup options as necessary. In Figure 1.14, the SQL Server service is installed but not started. You must start a service before you can test its installation.

Figure 1.13 Reviewing installed Windows Services

Verify Existence of Installation Folders Make sure that the configured default data folders and temp folders are present and that they contain the files that you expect, such as .mdf and .ldf files for the system databases. The location of these files will depend on the Data Directory configuration that you specified when you installed SQL Server. Connect to the Server We will cover the SQL Server clients in more detail in a moment, but one of the verifications that you will want to do is to attempt to connect to SQL Server. The simplest way to do this is to open a console window and use the command OSQL฀-E to log into the server. This assumes that you are connecting to a default instance through Windows Authentication mode. Once you authenticate, you will see a line prompt on the screen labeled 1>. Type a simple command such as the one pictured in Figure 1.14. Press the Enter key after typing GO to execute the batch.

Figure 1.14 Connecting to SQL Server with OSQL

27

28

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

If all is well, the screen should return version information. If you are unable to connect or if the command returns an error, verify that your services are running, that your account has permissions to access the server, and review the installation logs as necessary for problems. Type QUIT and hit enter to end the OSQL Session. Then type EXIT and press Enter to close the Command Prompt window.

Installing Sample Databases If, after installing the server, you want some sample databases to play with, you can download them from Codeplex.com. Go to the SQL Server section, where you can download installers for the various databases. Examples in this book will use the AdventureWorks sample databases, specifically the OLTP and DW databases, so you may want to have those installed for your reference.

The SQL Server Tool Set When you installed SQL Server, you had an option to install the client utilities as well. This client tool set consists of numerous configuration clients, command-line utilities, and development tools. In addition, there is also a thriving third-party market for SQL Server client tools. You can accomplish most of your day-to-day tasks with the out-of-the-box SQL Server utilities, but some of the third-party utilities are very convenient and make up for deficiencies in the Microsoft toolkit.

The Microsoft Client Tools Numerous utilities are installed with SQL Server. You will probably want to review the SQL Server Books Online to get a complete description of each of these and their capabilities, but the primary list is provided in the following text.

THE SQL SERVER MANAGEMENT STUDIO This is the primary SQL Server client. Introduced in SQL Server 2005, this utility replaces the Enterprise Manager and Query Analyzer tools found in SQL Server 2000 and earlier versions. Using this one tool, you should be able to handle the majority of administrative and development tasks. You will find the SQL Server Management Studio in the SQL Server program group in the Start menu. When you launch it, you will be prompted to log in. This is not required, but if you do log in, the tool will populate its Object Browser with catalog information and you will be able to perform tasks within SQL Server Management Studio without further authentication. How you authenticate will depend on the security setting that you chose when you installed the server. After authenticating, you will see a screen like the one pictured in Figure 1.15. If you do not see the details pane, press the F7 key on your keyboard.

THE SQL SERVER TOOL SET

Figure 1.15 The SQL Server Management Studio

Notice the tree view on the left. This is the Object Browser. Use this part of the screen to look at and configure your resources. The dialog makes good use of your secondary mouse button, so most of the options you want should be no further than a right click away. Also notice the Connect button in the upper-left portion of the browser screen. Use this to connect to other servers or other services on the current server. For example, you can use it to connect to multiple Data Engines on different servers or instances, as well as to an Analysis Server and a Data Engine on the same instance. To run a query, click the New Query button. A query window will open based on the current connection. This window works very much like the old Query Analyzer utility. Enter your query and click the Execute button or press the F5 key to execute the query. You will want to play around a little bit with your options in the client as you will use it often while working through this book as well as your daily work as a DBA or developer. We will address the specifics of what you can do with this client as the book progresses. As you start working with the query editors in the SQL Server Management Studio, you will probably stumble across one of the most-requested new features for the SQL Server development clients, called Intellisense. As you type, Intellisense will prompt you with lists of valid syntax or artifacts that you can use in your queries. It will also inform you of syntax errors and other problems as you type by putting red underlines in your code. Visual Basic and .NET developers have had these tools forever, and they have finally made their way into SQL Server, to the delight of the SQL Server development community.

|

29

30

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

In With the New, But Not Out With the Old One of the things that we like about the progression of SQL Server versions is that Microsoft still supports many of the old habits that you may have developed in your early days as a SQL Server developer. For example, back in the old days of SQL Server, when we used to use a tool called ISQL for query development, many of us got in the habit of using Alt+X to execute queries. That was replaced with Ctrl+E, which was ultimately replaced with F5. However, all of the old keystrokes are still functional. Author Mike Lee says, “Be it good or bad, I will probably be an Alt+X man until they play the Windows Shutdown .wav at my funeral someday.”

THE SQL SERVER BUSINESS INTELLIGENCE DEVELOPMENT STUDIO This tool is really just a set of Microsoft Visual Studio addins. It can cause confusion if you are not aware of what is happening. When you install this client, the Microsoft Visual Studio Development Environment is installed on your computer along with the specific development editors for the SQL Server Business Intelligence artifacts such as reporting, data cubes, and Integration Services packages. Remember that all of these BI artifacts are actually .NET executables, so the development environment for them is wrapped into the .NET container. If you already have the corresponding version of Visual Studio .NET installed on your computer when you perform the SQL Server client installation, it will not need to install the development environment, but only the environments for BI development. Therefore, to see what you really have installed in Visual Studio, start the tool and select File  New Project from the menu. The list of project templates will indicate what you have installed and available for use. Figure 1.16 illustrates a New Project dialog with just the BI environments available.

Figure 1.16 The New Project dialog in Visual Studio

THE SQL SERVER TOOL SET

|

THE SQL SERVER CONFIGURATION MANAGER Another very convenient tool is the SQL Server Configuration Manager illustrated in Figure 1.17. This utility provides a central configuration tool for all SQL Server services. In addition to the actual service configuration, you can also configure .NET libraries, client connectivity, and client aliases in one location. Prior to SQL Server 2005, this was done in multiple utilities. This welcome enhancement is preserved in SQL Server 2008.

Figure 1.17 The SQL Server Configuration Manager

The interesting thing about the SQL Server Configuration Manger is that it is a WMI client. As you browse though this client, you may be thinking to yourself that it would be nice to be able to control these features and get this information programmatically. This is possible through WMI. With a little bit of skill in .NET, a SQL Server DBA or developer can fully exploit the capabilities of SQL Server (and simplify their life, too).

PERFORMANCE TOOLS If you select Start  All Programs  Microsoft SQL Server 2008  Performance Tools from the menu, you will see two additional tools of note, the Database Engine Tuning Advisor and the SQL Server Profiler. While each of these will be discussed in more detail in later chapters, it is worth making a quick mention now of what they bring to the toolbox. The SQL Server Profiler is an indispensable tool for auditing SQL Server activity. In previous versions, the tool was called SQL Trace. In essence, its job is to listen for events that occur within SQL Server and log them to a file or to a table. When defining a profiler log, you can decide exactly which event you are interested in logging and what data about each event you want to log. Although the event and data lists are predefined, they are extensive. You can watch for events such as connections, procedure calls, and T SQL actions. For each of these events, you can track client information, connection information, server values, and other data. The real value in the SQL Server Profiler, though, is that is can be used for many different purposes, such as security auditing, performance tuning, and diagnostics. One of the most useful features of the SQL Profiler is to log T SQL calls and stored procedure calls. For instance, you can use the Profiler to log calls that are made by unfamiliar client applications. This allows the SQL Server DBA to know exactly what the client is doing even if it is a shrink-wrapped client or one with no documentation. You can use this information for performance tuning client applications or debugging problems that the client may be experiencing.

31

32

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

The Data Engine Tuning Wizard is another tool that has been around for a while, but the average SQL Server DBA probably does not use the tool to its fullest capability. While it is certainly not perfect, if you give it proper information regarding typical workflows, the Data Engine Tuning Wizard will make very reasonable recommendations related to indexing, and other performance optimizations. The Profiler and the Tuning Wizard work together effectively to improve performance. You can use the Profiler to capture a snapshot of typical database activity and then use this log as the input for the Tuning Wizard to make its recommendations. After altering the data structures based on the Tuning Wizard’s recommendations, you can replay the trace to see if the performance metrics improve. If not, you can start the whole process over again. We will address these two tools extensively in later discussions of performance analysis and management.

Third-Party Tools and Utilities First of all, the authors want to be perfectly clear that they are not attempting to promote, endorse, or recommend—let alone warranty—any third-party tools. There is good and bad in any tool, and just because we like a particular tool does not mean that you will, but there are a few big players in the data tools arena that you should be familiar with, if for no other reason than to give you material to captivate your audience with at the next big DBA cocktail party you attend. Embarcadero Technologies Embarcadero makes database products that fill quite a few holes in the marketplace. Their flagship tool is called ER/Studio. This is a design utility that puts the focus on good entity design. The concept is that if you can implement a good entity design, then a good data design will certainly follow. This is also a good product to use in a team environment. All design artifacts can be easily stored in a central data repository. Team members can log into the repository through the ER/Studio client and either check out designs for alteration or view them for reference. Another of the nice features of this tool is that it lets you export a data design structure as an HTML catalog, making it very easy to share the design with other users. Other Embarcadero products such as Schema Examiner and Rapid SQL aid the database developer by providing a solid platform for SQL development and schema management. Computer Associates Computer Associates (CA) makes a data modeling tool called ERWin® that is a competitor to the Embarcadero ER/Studio tool. The concepts and feature sets of the two tools are very similar, but the interfaces are different and each tends to create very loyal users who grow accustomed to the methodology behind the tool. CA has recently been making real strides in the SQL Server user community with the ERWin tool. Although the tool itself is and has always been Window-based, CA has been enhancing the tool’s image extensively within the SQL Server community, including partnering with the Professional Organization for SQL Server (PASS) to produce a series of webcasts targeted specifically to SQL Server users. Red Gate Software Red Gate also provides a good range of utilities, but unlike Embarcadero, Red Gate specializes in tools that are specific to Microsoft SQL Server rather than tools that work with a range of databases. Their SQL Compare and SQL Data Compare Utilities are quite effective for monitoring schema and data lineage changes. However, their SQL Prompt utility, which provided an Intelisense add-in for SQL Server management Studio, is unnecessary now that this feature is native in the Microsoft toolset.

THE BOTTOM LINE

|

Among the most compelling Red Gate tools is the SQL Backup tool, which handles the compression and encryption of SQL Server backups. Although SQL Server 2008 now supports these features, the ease of use of the Red Gate tool and the monitoring ability that it provides are still strong selling points. The Red Gate SQL Refactor tool is another real gem for the SQL developer because it gives you a great deal of control when formatting and refactoring code, allowing you to avoid the problems typically associated with copy-and-paste refactoring and reformatting. Quest Software Quest Software makes a great little development utility called TOAD. If you are an Oracle developer, you have probably heard of it, as it has become the de facto standard for Oracle development. Quest now makes a version for SQL Server. TOAD is an easy-to-use and intuitive client. It’s especially appealing at moments when the SQL Server Management Studio is a little too much to wade through—such as when all you want to do is execute some queries and write a few simple scripts. Best of all, there is a freeware version of TOAD for SQL Server, so you can try it out if you like. The full versions can be a bit expensive, but have a very loyal following. There are many other tools out there—far too many to review here. If your favorite tool was not on this short list, we apologize; it was not a deliberate snub. The important thing is to find tools that you like and tools with which you can work. With all of the good tools on the market, you should always be able to find the right one to help you get the job done. At the same time, you owe it to yourself to evaluate additional tools when you get the opportunity. You never know what gems you might uncover if you are willing to dig a little to find them. In the end, it’s all about getting the result you want as efficiently and cleanly as possible.

The Bottom Line Utilize the Architect SQL Server services in the typical IT environment. SQL Server provides more than just simple data services to the IT infrastructure. SQL Server is packed with so many features that it quite literally has become a data suite in a box. The key is making sure that you know what SQL Server can do and how to use the appropriate feature once you identify the need for it. Master It Which SQL Server feature would you use to meet each of the following business requirements? 1. Your company has been collecting sales data for over 10 years. The director of marketing has noticed that over the last two years, sales have been dropping in North America while they have been increasing in Central and South America. You need to see if you can find a reason for the trend. 2. Your company must comply with industry regulations that require the company to provide specific information in a specific format for regulatory inspectors. The inspectors must be able to get the information any time they choose, it must always be organized the way that they want to see it, and it must always contain current data.

33

34

| CHAPTER 1

OVERVIEW OF MICROSOFT SQL SERVER 2008

3. A significant portion of your firm’s sales is handled through the Internet. The marketing department would like to have a mechanism that allows users to search for a product, and if the product is not in stock, they can log in to the system and request to receive an email when the product is available. 4. Much of your company’s data is stored as large text fields. This text data must be searchable as efficiently as possible using very fuzzy logic including word forms and proximity searches. Install SQL Server 2008. While the installation process itself is wizard-driven, SQL Server installation takes some planning to make sure that you have an appropriate installation with the right resources in place for the right purposes. Master It SQL Server needs the right balance of resources to handle the demands of the data service. What are the four primary resources that SQL Server uses and how do they interact with each other? Use the Microsoft SQL Server toolset. Microsoft ships a number of high-quality tools with the SQL Server product that suit many different purposes. The key is to use the right tool for the job. Master It

Which of the SQL Server tools would you use for each of the following goals?

1.

Writing and executing a query

2.

Identifying the optimal indexing structure

3.

Performing routine security administration tasks

4.

Performing a security audit in which you try to identify failed login attempts

5.

Identifying the interaction between SQL Server and a compiled client application

6.

Configuring the network protocols that SQL Server can use

Implement other useful third-party tools. With all the tools out there, it is important that you select the right ones. There are a lot of tools from which to choose. Master It

What is the best third-party tool for creating entity-relationship diagrams?

Chapter 2

Understanding SQL Server Architecture If you’re going on a road trip, you better bring a map. Without that map you could end up anywhere. If you travel without a map and without clear directions, you’ll probably end up far from your intended destination. The same is true with SQL Server. Unless you understand SQL Server architecture, you’ll never know where you might end up on your performance-tuning and database-development journey. This chapter strives to be your road map so that you don’t have to ask for directions. Although we could never exhaustively cover SQL Server internals and architecture in one chapter, we hope that this one will at least be a good map for you to follow as you learn more about how SQL Server behaves. In this chapter, you will learn to: •u฀ Apply your understanding of SQL Server internals to implement good logical architecture •u฀ Utilize the SQL Server catalog to get more information about the system and your application •u฀ Effectively implement datatypes including user-defined datatypes

Essential Internals To begin, you need to find out what makes SQL Server tick. As you saw in Chapter 1, “Overview of Microsoft SQL Server 2008,” SQL Server functionality is an interplay between many resources— primarily memory, disk space, CPU, and network. Understanding this resource balance is critical in properly maintaining a SQL Server environment, and an intimate knowledge of SQL Server internals will simplify your day-to-day administrative and development responsibilities. In this section, we will examine the SQL Server data storage process and the functionality of the data engine.

SQL Server Data Storage Architecture SQL Server stores data durably on disk. It optimizes the format of these disk structures for performance and integrity. However, in most cases you’ll need to move SQL Server data from disk into memory before a client application can use it. Try to think about SQL Server data stored on disk as a snapshot; this is the way the data appeared when it was last flushed from memory to disk. Data in memory is current. Data modifications are generally made in memory, not directly to disk. This is why it is critical to understand how and when data moves between memory and disk. To lay the groundwork for this understanding, we will first address physical data storage structures including transaction logs. Then we will look at memory and memory configuration.

36

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Finally, we will examine how the data engine processes the query and see how these resources work together to create a more efficient data environment.

PHYSICAL DATA STRUCTURES Like most other applications, SQL Server data is organized into files. When you create a database, you will identify the names and locations of these files. Creating a database requires the use of two types of files: data files and transaction log files. A database can have multiple data files and transaction log files, and it is required to have at least one of each. Data Files Data files store all of the information in the database including data values, indexes, and even configuration data and programmatic objects such as stored procedures and functions. The data files are, therefore, the main repository in the database. Transaction Log Files Log files provide a durable record of all modifications to the database. SQL Server uses a write-ahead modification process that requires all changes to be written to transaction logs before they are written to the database. These logs enable a variety of data recovery and integrity features.

SQL Server Filenames The documentation that comes with SQL Server recommends the use of specific file extensions to identify SQL Server file structures. Every SQL Server database has a data file known as the primary data file. The convention states that this file should use an .mdf extension. Additional data files, known as secondary data files, should use an.ndf extension. Transaction log files typically use an .ldf extension. Although this is the convention, SQL Server does not enforce these rules. It is a good idea, however, to comply with these conventions for clarity unless you have a specific and well-documented reason for varying from the standard.

To allow SQL Server to locate any data value quickly and efficiently, these data files must be organized in a way that gives the SQL Server data engine full control of the specific placement of any data value. SQL Server accomplishes this by organizing data file structures into 8KB blocks called pages. Pages are further organized into 64KB blocks called extents. Typically, pages in a data file are allocated specifically for only one purpose. For example, you will not see data values and index entries in the same data page. SQL Server has many kinds of pages. Data Pages Data pages store all data values except those typed as large value types such as text, ntext, xml, varchar(max), etc. The majority of pages in a typical database will be data pages. Index Pages Index pages store index entries for both clustered and nonclustered indexes. These entries typically consist of the index key values themselves plus additional information used by SQL Server to locate data entries and manage the index process. Large Object Pages Because SQL Server data rows cannot span multiple data pages, large data values must be stored in alternative locations in cases where the data value is too large for the data page. Datatypes such as text, ntext, xml, varchar(max), etc. will typically store a small pointer on the data page that references the large object page where the data entry begins.

ESSENTIAL INTERNALS

|

Some datatypes such as text and varchar(max) will always be stored in large object pages. Others, such as varchar and varbinary, will be moved to these pages dynamically by SQL Server when the data row size exceeds 8KB. If, in the future, the variable length columns are edited and the size of the data row falls within the 8KB limit again, the data will be moved back to the data page. Other Pages Additionally, SQL Server stores other configuration information in special pages designed specifically for those configurations. These special page types include the Global Application Map, Index Application Map, Bulk Changed Map, and others. Pages are organized into extents. Each extent contains exactly eight contiguous pages. Extents are the basic unit of allocation in SQL Server. When the data engine allocates disk space to an artifact such as a table or index, it will generally allocate an entire extent. This reduces the frequency of allocation and also ensures a greater degree of contiguity in the physical data structure. These extents that are allocated entirely to one artifact are referred to as uniform extents. In some cases, where artifacts are very small and would not require an entire extent, it is possible for the data engine to allocate pages for multiple artifacts from a single extent. This is referred to as a mixed extent. Mixed extents are particularly useful when there are a large number of smaller artifacts that would not themselves fill an entire 64KB block. Because the SQL Server data engine will need to be able to locate any data value at any time, it is important for SQL Server to keep an accurate recording of exactly which extents are allocated to which artifacts. This is also important because once an extent has been allocated to an artifact, that extent is no longer available to be allocated to another artifact. SQL Server manages extent allocation information through the use of two allocation maps: the Global Allocation Map (GAM) and the Shared Global Allocation Map (SGAM). Each map stores allocation data for up to 64,000 extents by using bit settings to track each extent. This means that a single map page can support almost 4GB of data. The GAM uses a bit to track whether each extent is free or allocated. The SGAM specifically monitors mixed extents, using a bit to identify any mixed extent that has free pages available. There are also special pages called Page Free Space (PFS) pages, which are used to track the amount of free space on each individual page and whether or not that page has been allocated. Once the data engine has allocated an extent, it uses this PFS data to determine which of the pages in the extents are being used and how much of each page is being used. The entire allocation tracking system in SQL Server is designed to make the process of allocating new data structures as fast as possible and minimize exposure to error. Typical production databases are getting larger and a data explosion has occurred as a result of data warehousing; therefore, it should be obvious how important managing the data allocation process really is. Because a more detailed discussion of physical data structures is beyond the scope of this book, you may want to review SQL Server Books Online for more comprehensive information.

TRANSACTION LOGS Unlike data structures, transaction logs are not organized into pages. This is because transaction logs represent a substantially different structure. Rather than being blocks of data that can be accessed on a random basis, transaction logs consist of a sequence of actions whose inherent value is in maintaining the sequence. As a result, transaction logs are stored as a sequence of operations rather than as blocks of data.

37

38

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

To guarantee that the sequence of actions will be preserved, every transaction log entry contains a log sequence number (LSN), which identifies the specific order in which the actions occur in the database. Multiple actions that are part of the same transaction are encoded with the same transaction ID and linked together through backward pointers, thereby ensuring that multiple operations in a transaction can be committed or rolled back atomically.

Two Different Worlds At first it seems counterintuitive that SQL Server would store data and transaction log entries in such different ways. Remember, though, that SQL Server stores data structures and transaction log structures in completely different files. This makes it easier for SQL Server to manage the different storage processes. Data files need to be organized into pages and extents. Transaction log files do not need to be organized in this way, but rather as a series of log entries. This difference in data storage process is one of the reasons that SQL Server stores data and log entries in separate files. Another important reason for the split is data recovery, which will be addressed in detail in Chapter 9, “Data Recovery.”

The logical architecture of the transaction log is organized into a series of virtual logs. Because log space is freed when transaction logs are truncated, there must be a mechanism by which that free space is made available to the database engine. SQL Server accomplishes this by using a wraparound process as illustrated in Figures 2.1 through 2.3.

Figure 2.1

Virtual Log

Virtual Log

Virtual Log

Virtual Log

Virtual Log

Transaction logging

Start of Log

Min LSN

End of Log

Free Space

In Figure 2.1, the transaction log is organized into multiple virtual log structures. These log structures are of no predetermined size, and there is no predetermined number of virtual logs. As transaction logging begins, space is used in the virtual logs in sequence. This space comes from the one or more log files associated with the database. The MinLSN marker is the point representing the oldest log record that is required to be present in the log to perform data recovery. Assuming that the transaction log is truncated at the point illustrated in Figure 2.1, the truncation cannot take place any further forward than the MinLSN marker. Anything before that marker is not necessary for full database recovery and can be removed. That truncated space is now free to store new transaction data. However, because that free space is located logically before the current transaction activity, SQL Server must provide some mechanism to allow that recently truncated space to be accessed.

ESSENTIAL INTERNALS

Figure 2.2

Virtual Log

Virtual Log

Virtual Log

Virtual Log

Virtual Log

Truncating the inactive log

Truncated

Start of Log

Min LSN

End Free of Space Log

Figure 2.3 Wrapping the log

Virtual Log

Min LSN

Virtual Log

End of Log

Virtual Log

Truncated

Virtual Log

Virtual Log

Start of Log

In Figure 2.3, the end of the sequence of virtual logs is reached before the transaction logging process completes. Although no more free space is available at the end of the sequence of virtual logs, there is free space back at the beginning. The log will, therefore, wrap around back to the beginning of the sequence of virtual logs and begin the process again.

Virtual Logs and System Performance Although virtual logs rarely cause performance problems, one notable exception is when incrementing transaction log size. An administrative best practice is that if files need to be increased in size, they should be increased less often and in larger increments. If an administrator chooses to take a hands-off approach by setting the transaction log file’s auto increment setting, particularly if this is a small value, the result is a larger number of smaller transaction log fragments. In this case, each small fragment will be generated as its own virtual log. This can create a very large number of virtual logs and, therefore, have an adverse effect on system performance overall.

Although a few operations are not included in the transaction log, almost all data modifications are written to the transaction log before they are written to the data page. Transaction logging cannot be disabled. Although this does provide durability of data modifications, it significantly increases overhead both in memory and on disk. Exactly what values the system writes to the transaction log depends on the data modification it is performing as well as the circumstances of that modification.

|

39

40

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

When data inserts are performed, the entire inserted row is inserted into the transaction log. This allows the insert operation to be recommitted in the database if it becomes necessary to apply the transaction log due to data loss. Insert operations can be rolled back before the transaction commits by using the identifying data in the log. The data engine also records the entire record that was deleted in the transaction log. This provides the option of rolling back the delete operation by reinserting the data recorded in the transaction log. The log also contains a marker that allows the delete to be recommitted to the database if necessary. Update operations are more complex. Updates generally take place in one of two ways: as an update in place or as a delete/insert. These two techniques can differ significantly in the amount of overhead required to complete the update operation. Because the update-in-place technique requires significantly less overhead, the query optimizer will choose this option whenever it can. However, there are very specific requirements for executing an update in place. Delete/Insert Updates This is the default mode of performing a data update in SQL Server. This approach requires the greatest level of logging. After any necessary “BEGIN฀TRANSACTION” marker in the log, the entire row is written to the transaction log as it appeared before the updates occurred. Following the updates, the entire row is written again to the log. This provides both a “before” and “after” view of the data modification. Finally, any necessary “end transaction” markers are written to the log. Update in Place When certain conditions exist, it is possible to write the logical operation to the transaction log instead of performing a full delete and a full insert. Some of these conditions include: •u฀ The table cannot be marked for replication. •u฀ The table cannot have update triggers. •u฀ The total length of the data row before and after the update must be the same. •u฀ The update operation cannot modify a clustered index key.

The general rule of thumb is that an update in place is not allowed if the update operation repositions a row on the page, repositions any other row on the page, or requires a complete before and/or after view of the data due to other considerations such as replication or triggers. In addition to data modifications, the transaction log also stores other operations (for example, extent allocations and page allocations such as creating, dropping, or truncating tables or indexes).

MEMORY ARCHITECTURE Data is stored durably in files, but generally it must be brought into memory to be used by client applications. Having sufficient memory is vital to SQL Server performance; however, having a proper configuration to make maximum use of that memory is even more critical. In this section, we will look at the role memory plays and how to properly configure it for maximum impact. SQL Server uses a lot of memory. Memory is required for storing process objects such as user connections and worker threads. Memory is also required to store procedure execution plans, thereby providing one of the primary benefits of the store procedure—the ability to execute the procedure from a memory-resident store. However, by far the largest allocation of memory in SQL Server is reserved for data. Data memory is dynamically managed by SQL Server, which allocates and deallocates memory as needed.

ESSENTIAL INTERNALS

|

The organization of the memory reserved for data, also called data cache or buffer cache, mimics the organization of its physical disk counterpart. Just as the physical disk is organized as pages, memory is organized into a pool of 8KB buffers used to store data pages. Accessing data stored in memory is much faster than accessing data stored on disk. As long as the buffer remains intact in memory, no disk I/O is required to read or write a data value stored in the buffer. If there is insufficient memory to store the most commonly used data, swapping must occur. This means that data must be continually moved back and forth between memory and disk. Although common in SQL Server, swapping is a time-consuming process that should be minimized to the extent possible. So how much memory can SQL Server actually use? The answer to that question depends on a variety of factors. The primary factors are the CPU architecture of the server and the version of SQL Server that is running on that server. A 64-bit processor can address more memory than 32-bit processors; however, a 32-bit version of SQL Server running on a 64-bit architecture does not fully utilize the capacity of the hardware. When properly coerced through configuration settings, a 32-bit processor can use memory not normally accessible. Table 2.1 lists the user-addressable memory capacity of SQL Server in a variety of typical configurations. Unless otherwise specified, it is assumed that a 32-bit version of SQL Server is running on a 32-bit Windows version. The parallel assumption applies to 64-bit implementations.

Table 2.1

SQL Server Memory Configurations

Configuration

32-bit

64-bit

Conventional

2GB

Up to OS Maximum Limit

/3GB boot parameter

3GB

Option not supported

WOW64

4GB

Option not supported

AWE

OS Version Dependent

Option not supported

In a 32-bit environment, SQL Server is limited to 2GB of physical addressable memory under conventional circumstances. Due to the limitations of the Windows 32-bit memory architecture, only a total of 4GB of physical memory are addressable by the operating system. By default, 2GB of memory are reserved for operating system use only, and the remaining 2GB of memory are available for application use. Even in the most rudimentary of production scenarios, 2GB of memory is insufficient for most SQL Server applications. Starting with Windows Server 2000 Advanced Server, the server administrator can add the /3GB switch to the boot.ini file to reallocate server memory. Using this option, the 4GB of addressable memory are redistributed such that the operating system is granted access to 1GB of memory while applications can address 3GB. This extra gigabyte of memory can make a significant difference in some applications. Consider another situation where you may have multiple SQL Server instances running on the same physical server. Each of these instances is responsible for maintaining its own memory pool; however, with no special memory options enabled, those instances must compete for the same 2GB of available application memory. Although SQL Server will dynamically allocate memory as needed, the two instances of SQL Server will essentially starve each other’s memory needs.

41

42

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

The solution is to use the /PAE switch in the boot.ini file. This switch controls the Physical Address Extensions that allows more than one application to use memory beyond the 4GB limit. In such cases, each SQL Server instance would get its own 2GB block of memory, assuming physical memory is available, and would not compete with the other instance of SQL Server for memory resources. If used in conjunction with the /3GB switch, each instance would have access to 3GB of physical memory.

The Perils of the /3GB Switch Although it is very useful, the /3GB switch can cause problems. First, you must make sure that this switch is compatible with your version of Windows. This is an operating system option, not a SQL Server option. It is not supported on the standard Windows 2000 Server; it is supported only on Advanced Server and higher. It is fully supported on Windows Server 2003. Another problem occurs when you use the 3/GB switch in conjunction with the /PAE option. If the /3GB switch is used when the machine has more than 16GB of physical memory, the server will not be able to access any memory over the 16GB threshold. This is because the operating system needs the full 2GB of memory to be able to address any memory over the 16GB threshold.

Another extended memory configuration option is Address Windowing Extensions (AWE). This option can significantly increase access to extended memory above the standard 2GB application limit. The amount of increase depends on which Windows version you are using. Windows 2003 Server can use up to 4GB application memory under AWE. Windows 2003 Enterprise supports up to 32GB application memory, and Windows 2003 Datacenter increases this limit to 64GB. To configure AWE in SQL Server, set the advanced option, AWE Enabled, to 1. This option allows SQL Server to use physical memory up to the operating system limit. Before enabling this option, you should also configure the Lock Pages in Memory policy to prevent extended memory from being paged to disk. You should also consider configuring the SQL Server option Max Server Memory to an appropriate value. This is especially important if you have more than one instance of SQL Server running. In this case, each instance should have a Max Server Memory setting configured such that the total of all Max Server Memory values do not exceed the physical memory amount that will be made available to applications. You should consult SQL Server Books Online for specific details of AWE configuration. When SQL Server is running on a 64-bit processor architecture, the rules change. If you are running a 32-bit version of SQL Server on a 64-bit platform, SQL Server can use up to 4GB of memory using WOW64 (64-bit Windows on Windows). WOW64 is nothing more than 32-bit applications running on a 64-bit platform. The platform itself, however, provides access to 4GB of memory without any special configuration. The easiest option is to run a full 64-bit architecture. Although 64-bit architecture is capable of addressing over 18 exabytes (one quintillion bytes) of memory, this is not practical and lower limits are utilized based on processor type. X64 processors can handle up to 8TB of memory, and IA64 processors can handle up to 7TB of memory—all without any special configuration. When choosing the optimal memory configuration for your applications, you must consider trade-offs such as the amount of memory required for your application, costs of hardware, and

ESSENTIAL INTERNALS

|

administrative overhead. Be advised, however, that the movement in the industry is toward a 64-bit architecture due to the ease of configuration and the extensibility of the platform for future growth.

CPU ARCHITECTURE Although the CPU architecture does have a significant impact on memory and its configuration, the role of the processor is primarily to execute threads. Do not lose sight of this fact when you select an appropriate processor or multiprocessor architecture. Numerous options are available in the market today, including multiple sockets, multiple cores, and hyperthreading technology. The Windows operating system uses a preemptive scheduler to assign threads to processors. This means that a single thread of execution will be able to use the processor until its time slice expires, it finishes its work, or it is interrupted by a thread of a higher priority. Although this process works well for foreground applications, it can cause significant performance problems with SQL Server because a thread may still hold locks on data resources even if it is not actively executing. For that reason, SQL Server has its own scheduler service that manages all thread activity. Because SQL Server typically handles multiple concurrent requests from client applications, and each of these requests should hold locks for the shortest possible duration, performance can be enhanced by having multiple processors available to handle these requests. There are a number of ways this can be accomplished. One approach is to use a mainboard with multiple processor sockets and provide SQL Server with multiple processors. Although this approach gives SQL Server the ability to process multiple threads concurrently, it does have some drawbacks, primarily cost. SQL Server is licensed per socket; therefore, a SQL Server licensed for four CPUs can use a maximum of four sockets. This is also a cost inefficient method of adding processor power. A more common approach is to use multicore processors. Each core appears to the operating system as a separate processor, although SQL Server licenses the socket instead of the core. Four sockets with dual-core processors provide eight logical processors to SQL Server, but they require only a four-processor license. Multicore processors also have some performance advantages due to shared onboard cache. Another option is the Intel hyperthreading technology. Hyperthreading captures the unused processor cycles from a given processor and creates from that excess capacity, a logical processor that is visible to the operating system. For each core, a “phantom” processor, which appears to be a real processor to the operating system, is created. The theory is that the phantom processor can capture all available processor cycles so that each physical processor is completely utilized. In most cases, this results in performance gains due to the full utilization of the processor resources. In some cases when the physical processor is not already fully utilized, this can provide a performance benefit. However, in environments where the physical processor is already utilized to its maximum potential, the result is much different. Hyperthreading creates a phantom processor; but with no excess capacity from the physical processor, this phantom has no ability to efficiently handle assigned processing tasks. Because the operating system cannot tell the difference between the physical processor and the phantom processor, work cannot be effectively distributed among these resources. The result is potential performance degradation due to processor queues that cannot be handled by the phantom processors.

43

44

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

The Data Engine In later chapters, we will discuss the specifics of how SQL Server executes queries and utilizes indexes. In this chapter, we will lay the groundwork and focus on the mechanics of the data engine. Specifically, we are concerned with the interaction between disk and memory and the role that this interaction plays when data extraction and manipulation takes place. Let’s begin by looking at the diagram in Figure 2.4; it illustrates the interaction among these resources.

Figure 2.4 The SQL Server query process

Client Workstation

SQL Query

SQL Server Data Engine Memory Flush Data Pages

Tabular Data Stream

Read Data Pages

Disk Storage

Query Processor

In this diagram, you can see the interaction between the client workstation and the SQL Server data engine. This diagram shows a separation between the query processor and the I/O system that is responsible for managing memory and disk behavior. Let’s follow the logical flow of the query request from a client through the system. The process begins with the client workstation submitting a SQL query to the SQL Server. Before SQL Server can determine exactly which data pages on disk or in memory must be used to return the desired results to the workstation, the query must be first parsed, optimized, and compiled into an execution plan that the data engine can follow. This execution plan will tell the data engine exactly which data pages and index pages should be used to execute the query. This indexing and optimization process will be discussed in detail in Chapter 14, “Indexing Strategies for Query Optimization.” Once the data engine has an execution plan to follow, it can retrieve the necessary data to be returned to the client. As you can see in Figure 2.4, the initial resolution of the query request is made to memory, not disk. In most cases, data reads or writes are not made directly to disk, but rather from memory. Just as data files are organized into pages, memory is organized into buffers. Each buffer is 8KB in size and stores a single page from disk. When data is retrieved from disk into memory, an entire data page is read from disk. If a client workstation submits a query that requires data

ESSENTIAL INTERNALS

|

from a specific page, the initial action will be to attempt to locate that page in a memory buffer. The necessary data value can then be extracted from the buffer, packaged with the other requested values into a Tabular Data Stream (TDS), and returned to the client. But what if the needed page is not currently stored in a memory buffer? Then the data must be read from disk. At this point, the SQL Server data engine makes an I/O request to pull a page from disk into an available memory buffer. Once in the memory buffer, the necessary data value can be extracted and returned to the user in the Tabular Data Stream. This requires additional physical I/O and will generally hurt performance. As you can see from this scenario, if the data page has already been read into a memory buffer, no additional disk access is required to resolve the query. Because memory access is much faster than disk access, the performance of this query would be substantially better than if the query acquired data from disk. The more memory that is available to store commonly used data, the better performance will be. This process is the same for data modifications. When executing INSERT, UPDATE, or DELETE statements, the data must be retrieved to memory before the data modification can be made. Following the data modification, the buffer will eventually be flushed back to disk. So what happens if there is not enough memory available to store data pages that must be read from disk into memory? And what exactly constitutes available memory? To answer these questions, we must examine memory architecture a little more closely. Each memory buffer generally exists in one of three basic states: free, available, and dirty. Free Buffers Free buffers, sometimes called empty buffers, are memory buffers that currently store no data. These buffers represent available space for page reads from disk to memory. Because SQL Server dynamically allocates memory based on current needs, free buffers are very fluid and they are allocated and deallocated as necessary. A consistently high number of free buffers means that memory space is not being fully utilized. Available Buffers Available buffers currently store data from disk that has not been modified since it was read from disk into memory. If the buffer has not been modified, the page on disk and the buffer in memory should look exactly the same. If this is true, the buffer can be overwritten with new data without losing any existing modifications. For this reason, SQL Server views these buffers as expendable. It will, however, use the available buffers on a “least recently used” basis. Available buffers that have not been accessed recently are more likely to be overwritten with new data. Dirty Buffers Dirty buffers are buffers that have been modified since they were read into memory. Once a page has been read into memory, it may experience data modifications requested by client applications. If the memory buffer has been modified, the buffer in memory is no longer identical to the page on disk. Remember that disk storage is simply considered a snapshot of what the data page looked like at a specific point in time. A memory buffer is considered to be the current form of the data page. Dirty buffers must be written to disk before they can become available again to store new data. If these buffers are not written to disk, the data modifications will be lost. SQL Server uses many techniques to write dirty buffers from memory to disk, but the most common is the Checkpoint process. When a database checkpoint occurs, all dirty buffers for that database are written from memory to disk. After the checkpoint, the buffers are not cleared but rather are considered to be “available” buffers.

45

46

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

The Case of the Disappearing Dirty Buffer The Checkpoint process ensures that dirty buffers are written from memory to disk before those buffers are reused for other data. However, if the buffers did not get the opportunity to checkpoint— due to a power failure, for example—the data modifications stored in the dirty buffers are lost. Where do these data modifications go, and how can we restore them? Author Mike Lee once had a consulting client that faced this very dilemma. This was some years ago, and the client, a small insurance agency in the Western United States, was new to SQL Server and did not have the resources to hire a full time database administrator. Not fully understanding the appropriate configuration of SQL Server, the agency had enabled an option that would truncate the transaction log with every checkpoint to ensure that the transaction log did not fill up. They did this in an effort to manage the size of the transaction log. What they did not realize was that they were exposing themselves to data loss. As part of SQL Server’s performance architecture, the data engine will allow a dirty buffer to remain in memory until the benefit of performing a checkpoint on the database is greater than the overhead of performing that operation. The longer a dirty buffer can remain in memory, the more likely it is to be modified by other client requests. By delaying the Checkpoint process, this dirty buffer may experience multiple modifications but will only have to be flushed once, thereby reducing overall I/O. To prevent exposure to data loss in the volatile memory, all transaction log records associated with a specific transaction are immediately flushed from memory to disk as soon as a transaction successfully completes. Therefore, the transaction log on disk provides the durable record of all data modifications, including those buffers that have not yet been flushed to disk. To return to our tale, when the agency’s SQL Server went down, all of the dirty buffers in memory were lost because they had not been part of a database checkpoint process. The transaction records were useless because the truncation of the transaction log with each checkpoint prevented that log from being restored back to the database. In their case, the buffers simply disappeared and could not be recovered. If they had fully understood the memory and disk architecture of SQL Server, they would have chosen different transaction log settings and could have preserved their data. The important lesson to learn from this example is that knowledge of system architecture is not just an academic exercise. In many cases, understanding the specifics of system behavior can mean the difference between a reliable data environment and a data disaster.

Data is typically flushed from memory to disk during the Checkpoint process. The frequency of the checkpoint is controlled by the server, but typically each database is evaluated for checkpointing every minute or so. If in this check, it is determined that the database has accumulated sufficient data modification to warrant a memory flush, the database checkpoint will occur. Another technique that SQL Server uses to write pages from memory to disk is the LazyWriter. Sometimes the number of free and available buffers falls below an acceptable value before the database can checkpoint. If all buffers are dirty, the SQL Server will halt due to the inability of the server to place needed pages into available memory. The LazyWriter handles these situations. When necessary, the LazyWriter will write dirty pages from memory to disk and mark the buffers as available. This enables SQL Server to have sufficient memory for its data needs.

ESSENTIAL INTERNALS

|

SQL Server and Windows In the early days of SQL Server, the product was just for Windows. Version 4.2 of SQL Server and its Sybase predecessors also supported the Unix platform. Since the release of SQL Server 6.0, it has lived in a Windows-only world. There were a number of reasons for this transformation including: •u฀ Marketing •u฀ Reducing the maintenance costs of SQL Server releases •u฀ Enabling tighter integration with the Windows platform

From a marketing perspective, the success of this transformation is open to debate: one substantial impact of this decision was that Microsoft’s development team on SQL Server could focus their efforts on the Windows platform and exploit all the benefits that Windows provides. This has enabled Windows Server operating systems and SQL Server database systems to grow together to the point that today they are highly integrated parts of the Windows data platform. Although a discussion of Windows internals is far beyond the scope of this book, there are a few key concepts that you should understand regarding the relationship between SQL Server and the Windows platform. SQL Server is a Windows service. It doesn’t get more basic than this. All SQL Server functionality—including the data engine, the scheduling engine, the SQL browser, etc.—runs as Windows services. Windows services have some important characteristics including: •u฀ Background processing priority •u฀ Service logon authority •u฀ Autostart behavior

Windows performs all SQL Server I/O. SQL Server does not perform any of its own I/O activities. It relies on Windows to perform these actions. When a data page needs to be read from disk, SQL Server sends the request to Windows, which locates the appropriate disk location and reads the data into memory. It is SQL Server’s responsibility to keep track of the data on every 8KB page and provide Windows with the appropriate page address for read or write. Windows does not know or care what is on every page. Windows does not even realize that the 8KB block of data that it is reading or writing is a data page. In this way, Windows manages the physical I/O process while SQL Server manages the logical I/O process. Windows manages all hardware. SQL Server is not allowed to interact with any hardware, be it network cards, memory, controllers, etc. For this reason, the database administrator generally tunes hardware resources by tuning the Windows platform, not by tuning SQL Server. Although some configurations allow SQL Server to specify which hardware resources it will use, it is up to Windows to manage these resources. In other words, setting a configuration such as Processor Affinity or Max Server Memory in SQL Server will control only what SQL Server requests, not the way Windows manages that request or optimizes the resource. To be a truly proficient database administrator, you should be comfortable with the Windows platform. Companies and data environments delegate database authority differently. Tuning and configuring the Windows platform could be the responsibility of the network administrator,

47

48

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

or the database administrator could have no rights in this area whatsoever. Regardless, it is important for the database administrator to be knowledgeable about platform configurations so that he or she can communicate effectively with the platform professionals who are the gatekeepers of the SQL Server’s operating environment.

The SQL Server System Catalog In addition to the internals of SQL Server, the database administrator must also understand the SQL Server catalog structure. SQL Server stores information about its own configurations and all user data in a series of system tables and system databases. The proficient database administrator should be intimate with these catalog features. As SQL Server gets more complex, so does its catalog structure. Therefore, a small investment in understanding the SQL Server catalog will pay off significantly as you begin to tune and maintain your server.

The System Databases A typical installation of SQL Server has four standard system databases. They store all the required information for SQL Server’s internal configuration. These databases are Master The master database stores all of SQL Server’s global configurations. In essence, the master database contains all of the information that SQL Server knows about itself, its own configuration, and its current status. This data is stored in system tables and is made available to the database administrator through system views and functions. Many TSQL operations modify the master database. For example, when you create a new user database, entries are made in the master database catalog that track the file structure and the logical database structure of the database that you just created. Likewise, adding a new login to SQL Server also modifies the master database catalog. Model The model database is the template for every new user database created. The model database contains all of the system structures that are found in every user database. Additionally, a database administrator can add artifacts to the model database, which would include all of the artifacts in every new user database created on that server from that point forward. The model database can be extremely convenient when standardizing structure, features, or artifacts for every new user database. Msdb The msdb database contains all the catalog information to support the SQL Agent service, which is SQL Server’s scheduling service. The SQL Agent allows the database administrator to create jobs, schedule jobs, and configure alerts for when those jobs succeed or fail. All of the scheduling information is stored in system tables in the .msdb database. This database also contains information concerning replication publication and replication schedules. Tempdb The tempdb database stores internal SQL Server work structures used in the process of resolving queries. This database can store worktables generated automatically by SQL Server as well as temporary tables created explicitly by the SQL developer. Tempdb is also where cursor overhead is stored, whether the cursor is generated on the server through SQL code or requested as a server-side cursor from the client. Unlike the other system databases, tempdb does not have to be backed up because it contains no permanent information. In fact, tempdb is cleared as a part of the normal shutdown process.

THE SQL SERVER SYSTEM CATALOG

|

System Tables, Views, and Functions In addition to the system tables that are part of the catalog of the system databases, there are also system structures that are part of every user database. In both the system databases and the user databases, the system tables are augmented with system views and functions that organize system data and make it available to the database administrator (DBA) in a consumable fashion. Using these system views and functions, the database administrator should have access to all relevant configuration information for the server as a whole or any individual database.

Where Did My System Tables Go? If you are familiar with SQL Server 2000 and earlier, you are used to being able to access system tables directly. Expanding the system tables node in the SQL Server Management Studio is an extremely frustrating experience if you are used to accessing any system table at any time. The list that you get is extremely empty. Starting with SQL Server 2005, Microsoft has moved much of the information that we formerly retrieved from system tables into system views and functions. The level of system table abstraction that started with SQL Server 2005 has been extended in the 2008 release, and Microsoft plans to eliminate all direct system table access in the next release. With this in mind, you should become familiar with the system views and functions now. By using these artifacts, you can often get much better information from the system anyway.

Because the system table structure is essentially hidden from the database administrator, we will not focus on the system tables themselves; instead, we’ll turn our attention to the system views and functions that make up our interactive catalog. These system views and functions are well documented in SQL Server Books Online, so rather than review them in detail here, you should consult the documentation for more detail. We will, however, take this opportunity to introduce you to some of the more critical artifacts in the catalog and walk you through the process of using them. Tables 2.2 and 2.3 list some of the SQL 2000 system tables and their corresponding system views. This is not meant to be an exhaustive list, but merely gives you a taste of the available features.

Table 2.2

Master Database System Views and Functions

SQL 2000 System Table

Corresponding System View or Function in SQL Server 2008

sysaltfiles

sys.master_files

syscacheobjects

sys.dm_exec_cached_plans

sysconfigures

sys.configurations

sysdatabases

sys.databases

syslockinfo

sys.dm_tran_locks

49

50

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Table 2.2

Master Database System Views and Functions (continued)

SQL 2000 System Table

Corresponding System View or Function in SQL Server 2008

syslocks

sys.dm_tran_locks

syslogins

sys.server_principals฀ sys.sql_logins

sysmessages

sys.messages

sysoledbusers

sys.linked_logins

sysperfinfo

sys.dm_os_performance_counters

sysprocesses

sys.dm_exec.connections sys.dm_exec_sessions฀ sys.dm_exec_requests

sysservers

sys.servers

Table 2.3

All Database System Views and Functions

SQL 2000 Systems Table

Corresponding System View or Function in SQL Server 2008

syscolumns

sys.columns

syscomments

sys.sql_modules

sysconstraints

sys.check_contraints฀ sys.default_constraints฀ sys.key_constraints฀ sys.foreign_keys

sysdepends

sys.sql_expression_dependencies

sysfilegroups

sys.filegroups

sysfiles

sys.database_files

sysforeignkeys

sys.foreign_key_columns

sysindexes

sys.indexes฀ sys.partitions฀ sys.allocation_units฀ sys.dm_db_partition_stats

sysindexkeys

sys.index_columns

THE SQL SERVER SYSTEM CATALOG

Table 2.3

All Database System Views and Functions (continued)

SQL 2000 Systems Table

Corresponding System View or Function in SQL Server 2008

sysmembers

sys.database_role_members

sysobjects

sys.objects

syspermissions

sys.database_permissions฀ sys.server_permissions

sysprotects

sys.database_permissions฀ sys.server_permissions

sysreferences

sys.foreign_keys

systypes

sys.types

sysusers

sys.database_principals

Types of System Artifacts In earlier versions of SQL Server, all system data was stored in system tables. As SQL Server matured, some system data, such as active locks and processes, was dynamically generated but still visible to the administrator via a system table structure. If you did not know which data was stored in tables and which data was dynamically generated, the structure of the catalog did not make it obvious. This changed in SQL Server 2005 and continues in SQL Server 2008. System views and functions use naming conventions that can help us identify how the data was generated. Every system artifact begins with the prefix sys. This prefix is a system schema that is used to organize all system artifacts. (If you are not familiar with schemas, you can read about them in more detail in Chapter 8, “Managing User Security.”) When you see the sys. prefix, you know that you are dealing with a system artifact. This alleviates the need for a naming convention for the actual artifacts, as was used in SQL Server 2000 and earlier. Some artifacts use a dm_฀prefix. This prefix indicates that the data returned is not being pulled exclusively from system structures, but is dynamically generated from active system state. Knowing these conventions does not change your ability to use an artifact, but it can help you understand how the catalog is organized and how the data is being generated.

Because these system artifacts are typically views and table-valued functions, they can be used in queries in the same manner as the system tables were. In some cases, when the artifact is a table-valued function, it may be necessary to pass parameters when extracting information from the system catalog. This process can be very different from querying data directly from system tables, because the FROM clause typically does not take parameters. Let’s take a closer look at each of these techniques.

|

51

52

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

First, let’s look at a simple system view. One of the most common queries performed against the system tables is a check to the sysobjects table to verify an object’s existence. Try executing the query in Listing 2.1 against the AdventureWorks2008 database. This query uses the sysobjects system table.

Getting the Sample Databases The following examples use the AdventureWorks sample databases for SQL Server. If you do not have these databases installed, you can get them from http://w w w.codeplex.com/ MSFTDBProdSamples.

First, open the SQL Server Management Studio by selecting Start  All Programs  SQL Server 2008  SQL Server Management Studio. In the Connect To SQL Server dialog, set the Server Type to Database Engine and the Server Name to the instance to which you would like to connect. If you’re using SQL Server Authentication, you must also provide a login and password. Click the Connect button. Once connected, click the New Query button on the top left of the toolbar to open a new query window. After typing the query, click the Execute button on the toolbar to run the query. You can also use the F5 key, the Ctrl+E combination or the Alt+X combination to run the query.

Listing 2.1

Selecting from the Sysobjects System Table

USE฀AdventureWorks2008;฀ IF฀EXISTS( ฀฀฀฀฀฀SELECT฀1 ฀฀฀฀฀฀FROM฀sysobjects ฀฀฀฀฀฀WHERE฀xtype=’P’ ฀฀฀฀฀฀฀฀฀฀฀฀AND฀name=’uspLogError’ ) ฀฀฀฀฀฀PRINT฀‘Proc฀Found’; ELSE ฀฀฀฀฀฀PRINT฀‘Proc฀Not฀Found’;

Because this procedure is located in the AdventureWorks2008 database, it should print the appropriate message to the screen. But there is a small problem. The query refers to a procedure called uspLogError, but that name does not include the schema. Because there could be multiple procedures called upsLogError, all in different schemas, this is ambiguous. Try modifying the code on the sixth line to read AND฀name=’dbo.uspLogError’.฀Run the query again and look at the results. This time, you should see a message telling you that the procedure was not found. Why? The problem is that the name of the procedure does not include its schema. So the column that stored the name in sysobjects has no reference to the schema. In fact, if you look at the sysobjects system table more closely, you will see that there are no columns in the table that reference schema information. So we will have to find another way to filter the procedure list by schema. Take a look at the query and results in Figure 2.5.

THE SQL SERVER SYSTEM CATALOG

Figure 2.5 Querying the sys.objects฀ system view

Although the name of the procedure still does not contain this schema information, a schema column contains this data. Unfortunately, the schema ID returned in this table is of limited use unless you know to which schema the ID refers. To get this information, let’s evaluate another view, sys.schemas. Note that the schema ID of this procedure is 1. Look at the query execution pictured in Figure 2.6.

Figure 2.6 Selecting from the sys.schemas view

According to this query, the name of the schema having a schema_id of 1 is dbo. This means that the fully qualified name of our procedure is dbo.uspLogError. You may observe that this is a long way to get this information. There is a shorter way. By joining the views, we can create a single query that allows us to filter by schema name as well as object name. If we are performing an existence check for a procedure called dbo.uspLogError, our code should look like the example in Listing 2.2.

|

53

54

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Listing 2.2

Existence Checking with Catalog Views

USE฀AdventureWorks2008;฀ IF฀EXISTS฀( ฀฀฀฀฀฀SELECT฀* ฀฀฀฀฀฀FROM฀sys.objects฀as฀o ฀฀฀฀฀฀INNER฀JOIN฀sys.schemas฀as฀s ฀฀฀฀฀฀฀฀฀฀฀฀ON฀s.schema_id฀=฀o.schema_id ฀฀฀฀฀฀WHERE฀s.name=’dbo’ ฀฀฀฀฀฀฀฀฀฀฀฀AND฀o.name=’uspLogError’ ) ฀฀฀฀฀฀PRINT฀‘Proc฀Found’; ELSE ฀฀฀฀฀฀PRINT฀‘Proc฀Not฀Found’;

As you can see from this example, much more information is made available to the administrator through the catalog views than was previously available through the system tables directly. You may have to change a few habits, but the benefits of using the system views as opposed to the tables can be significant. You can use other system views in much the same way as in this example. Take the time to consult the documentation and find out which views are available. Experimenting with these resources now will give you an advantage down the road. Some of these system artifacts are not actually views, but instead are table-valued functions. Although a table-valued function can be called in the FROM clause of the query in the same way as a view, these functions sometimes accept parameters that must be provided before the function will execute correctly. These parameters are fully documented in SQL Server Books Online, but the query editor in the SQL Server Management Studio provides syntax prompts that will help you provide the needed information. As an example, look at the code in the following snippet. This listing shows a query against the system function sys.dm_sql_referenced_entities. USE฀AdventureWorks2008; SELECT฀* FROM฀sys.dm_sql_referenced_entities(‘dbo.uspLogError’,฀‘OBJECT’);

This function is similar in nature to the old฀sp_depends system-stored procedure, providing information about the artifacts upon which the indicated objects depends. To execute this function, we need to pass two parameters. First, we must provide the name of the referencing entity. You may optionally include the schema name if there is any chance of ambiguity. Second, we must provide a parameter called referencing_class, which indicates the type of artifact that is doing the referencing. This second parameter is a string, and it can be set to one of the following three values: •u฀ OBJECT •u฀ DATABASE_DDL_TRIGGER •u฀ SERVER_DDL_TRIGGER

In addition to these management views and functions, SQL Server still utilizes a significant number of other functions, primarily scalar functions, as part of the Transact-SQL language. These functions and their uses should look familiar to most database developers and administrators.

THE SQL SERVER SYSTEM CATALOG

|

Functions such as OBJECT_ID, CAST, COALESCE, etc. provide significant functionality to the SQL developer. Because most of these functions are scalar in nature, providing a single return value, they can be used in select lists, as criteria in a WHERE clause, and anywhere that a single value can be evaluated and used. Figure 2.7 shows an example of using one of the scalar functions in a query. This query uses two scalar functions: CURRENT_USER and USER_ID. This query returns a list of all schemas that are owned by the currently logged-on user. Notice how the USER_ID function is used in the WHERE clause to provide criteria for the query. Also note how the CURRENT_USER function is used to provide a value for the user ID. Because numerous functions provide extensive functionality as part of the Transact-SQL language, you will find a wealth of convenience if you are willing to do a little bit of searching. You can also create your own scalar functions if no built-in functions satisfy your requirements. This will be discussed in Chapter 5, “Procedural Programming.”

Figure 2.7 Using scalar functions in a query

System Stored Procedures System stored procedures are another important part of the Transact-SQL language and the server catalog. System stored procedures provide mechanisms by which you can alter system catalog contents without having to interact directly with the system tables. It is highly inadvisable to attempt to modify system tables. However, system stored procedures can perform these operations safely, and they should be the preferred administrative tool for performing these operations. For example, suppose you want to modify SQL Server’s configurations. Information about these configurations is stored in the system catalog. Even if you are able to locate the system tables where this information is stored, it’s not really a good idea to modify those system structures directly. Instead, you should let the system stored procedures assist you in this type of task. In this example, the appropriate system stored procedure is SP_CONFIGURE. Suppose you are interested in enabling the .NET Common Language Runtime in SQL Server. This configuration is disabled by default for security reasons. If you want to execute managed objects in SQL Server, such as stored procedures written in the C# language, you must first enable the Common Language Runtime. The following code snippet illustrates how this is done. EXEC฀sp_configure฀‘clr฀enabled’,฀1;

55

56

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

This statement will modify the server configuration setting for the Common Language Runtime integration. Notice that we did not have to interact directly with any of the system table structures. The SQL Server catalog has a lot of system stored procedures. You should review them to familiarize yourself with the capabilities that they provide. Experienced database administrators should note that a significant number of the system stored procedures are being deprecated and replaced with other Transact-SQL functionality. You should review the procedures that you commonly use before you define any new functionality in your applications or administrative scripts.

When Configuring Is Still Not Enough The previous example illustrated the use of the sp_configure system stored procedure. After executing the code in the snippet, you might think that the CLR was fully enabled. Unfortunately, this is not the case. Some configurations must be installed before they will take effect. If you execute the sp_configure procedure without any parameters, it will show you currently configured and running values as illustrated in the following graphic.

Compare the value for the config_value to the run_value for the CLR-enabled configuration. You will notice that the configuration is set for the CLR to run, but at this point the CLR has not yet launched because the run configuration value still shows the CLR as inactive. To install the configuration, you must run the reconfigure command. This will ensure that the SQL Server is running with all configured settings. Forgetting this extra step may result in an improperly configured server.

DATATYPING

|

Datatyping Although not part of the system architecture in the strictest sense, datatyping is included in this chapter because of its prevalence throughout the rest of the system. You cannot escape datatypes. When you define a table, you will need to specify its datatypes. Likewise, a parameter in the stored procedure or declared variable in a procedure or script will require datatypes. Additionally, you may also provide consistency in your application architecture through userdefined datatypes.

System-Defined Datatypes The list of new datatypes seems to grow with every new release of SQL Server, and SQL Server 2008 is no exception. Table 2.4 provides a complete listing of all SQL Server 2008 datatypes along with a short description of each. You should become very familiar with this list, along with the advantages and challenges of each type.

Table 2.4

SQL Server 2008 Datatypes

Type Name

Category

Description

bit

Exact Numeric

Integer storing 1, 0, “True,” “False,” or NULL.

tinyint

Exact Numeric

1 byte storing 0 to 255.

smallint

Exact Numeric

2 bytes storing –215 to 215– 1.

int

Exact Numeric

4 bytes storing –231 to 231 – 1.

bigint

Exact Numeric

8 bytes storing – 263 to 263 – 1.

decimal

Exact Numeric

Defined with precision up to 38 digits using format decimal [(p[฀,s])] where p฀is precision and s is scale. 17 bytes when used at maximum precision. Default precision is 18.

numeric

Exact Numeric

Functionally equivalent to decimal.

smallmoney

Exact Numeric

4-byte scaled integer (4 digits scale).

money

Exact Numeric

8-byte scaled integer (4 digits scale).

real

Approximate Numeric

4-byte floating point value.

float

Approximate Numeric

Defined using format of float[(n)]. 7 digits precision and 4 bytes size when n=1 to 24. 15 digits precision and 8 bytes size when n=25 to 53. Default n = 53.

smalldatetime

Date and Time

4 bytes storing date and time value from Jan 1, 1900 to June 6, 2079 with accuracy to the minute.

57

58

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Table 2.4

SQL Server 2008 Datatypes (continued)

Type Name

Category

Description

datetime

Date and Time

8 bytes storing date and time value from Jan 1, 1753 to December 31, 9999 with accuracy to 3.33 milliseconds.

datetime2

Date and Time

8 bytes (default) storing a value from Jan 1, 1 AD to December 31, 9999AD with accuracy to 100 nanoseconds.

date

Date and Time

3 bytes storing the date only from Jan 1, 1 AD to December 31, 9999.

time

Date and Time

5 bytes storing time of day with accuracy of 100 nanoseconds without time zone awareness. User can specify scale.

datetimeoffset

Date and Time

Equivalent to datetime2 with the addition of time zone awareness.

char

Character Strings

Fixed storage of ANSI characters using 1 byte per character + 2 bytes total overhead up to 8,000 characters.

varchar

Character Strings

Variable storage of ANSI characters using 1 byte per character + 2 bytes total overhead up to 8,000 characters. Up to 2GB storage when used as varchar(max).

text

Character Strings

Variable storage of ANSI characters using 1 byte per character. Note: This datatype will not be supported in future releases.

nchar

Unicode Character Strings

Fixed storage of Unicode characters using 2 byte per character + 2 bytes total overhead up to 8,000 characters.

nvarchar

Unicode Character Strings

Variable storage of Unicode characters using 2 byte per character + 2 bytes total overhead up to 8,000 characters. Up to 2GB storage when used as nvarchar(max).

ntext

Unicode Character Strings

Variable storage of ANSI characters using 2 byte per character. Note: This datatype will not be supported in future releases.

binary

Binary Strings

Fixed storage of binary characters using 1 byte per character + 2 bytes total overhead up to 8,000 characters.

varbinary

Binary Strings

Variable storage of binary characters using 1 byte per character + 2 bytes total overhead up to 8,000 characters. Up to 2GB storage when used as varbinary(max).

DATATYPING

Table 2.4

SQL Server 2008 Datatypes (continued)

Type Name

Category

Description

image

Binary Strings

Variable storage of binary characters using 2 byte per character. Note: This datatype will not be supported in future releases.

cursor

Miscellaneous

Type used to store a reference to a cursor in a variable or output parameter of a stored procedure.

rowversion

Miscellaneous

Reflects the functionality of the former timestamp datatype. 8 byte value for version stamping a row that is updated whenever a value on the row changes. The old timestamp syntax will be deprecated in the next release.

hierarchyid

Miscellaneous

A variable system datatype that represents position is a hierarchy.

uniqueidentifier

Miscellaneous

A 16-byte GUID value; when used in conjunction with the NEWID function is unique on the server.

sql_variant

Miscellaneous

Can store a value of any datatype except: varchar(max)฀ nvarchar(max)฀ varbinary(max)฀ xml฀ text฀ ntext฀ image฀ rowversion฀ sql_variant฀ any user-defined type

xml

Miscellaneous

Variable type storing up to 2GB data in a well-formed XML document or fragment format. Can enforce schemas if configured.

table

Miscellaneous

Variable type storing a table in a declared variable or stored procedure output parameter.

As you can see from this list, there have been numerous enhancements to the SQL Server datatypes. Most notably are the date and time datatypes. The addition of datetime2 increases the storage range and accuracy of date and time storage. The date type allows storage of date only without a time component, while the time type allows storage of the time only without a date component. This is an extremely useful functionality, which until the 2008 release, was missing from the SQL Server typing framework.

|

59

60

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Also note the planned future deprecations. The text,฀ntext, and฀image datatypes will be replaced by the varchar(max), nvarchar(max), and varbinary(max) datatypes, which provide similar functionality, but are much easier and more efficient to use. Also, the timestamp฀datatype will be replaced by the rowversion฀type, which provides equivalent functionality but uses the ANSI standard name.

What Do I Do with All These Types? Because datatyping is prevalent in SQL Server, we will wait to show you the specifics of how these types are used. For now, acquaint yourself with the different types so that you become familiar with their usage and their requirements. We will expect you to be familiar with these types when we mention them in later chapters.

User-Defined Datatypes To provide greater consistency across multiple tables and stored procedures in your database, you have the option of defining your own datatypes. When you define your own datatypes, it is always in terms of the system-supplied types that we have previously discussed. You cannot pull your own datatypes out of thin air. Each user-defined datatype is simply a specific implementation of an existing datatype for the purpose of consistent reuse within the database application. In ANSI standard terminology, user-defined datatypes are referred to as domains. Why would you want to use a user-defined datatype? Suppose you had numerous tables that store directory information. For now, assume that these tables store addresses within the United States and each address is required to include the state in which the address is located. There are many ways to store this information. You could use a character field to store the name of the state. You could also store a state abbreviation. The important consideration, however, is that you store the data in a consistent manner, ensuring that you have no stovepipe tables and all of the data can be effectively integrated. To attain this consistency, one approach is to use a system-defined type that best reflects your desired storage. For example, if you choose to use a two-character code for every state, you could define the state column in each table using the char(2) datatype. This works fine, as long as all the developers who create tables consistently use this type. Another option is to define a custom type that can be used everywhere a state code is defined. In this case, you could define a new datatype called statecode as a฀char(2) datatype. From this point forward, any time a developer wants to store the two-character abbreviation for a state, she would simply use the statecode type. The Transact-SQL statement used to create this type is the CREATE฀TYPE statement. The basic syntax of this statement is CREATE฀TYPE฀[schema_name.]type_name FROM฀base_type฀[NULL฀|฀NOT฀NULL]

Using the previous example, if we wanted to create a user-defined datatype called statecode as a char(2) and wanted the default table behavior to require a value to be entered for any field of this type, we would use the following syntax: CREATE฀TYPE฀dbo.statecode FROM฀char(2)฀NOT฀NULL;

DATATYPING

|

At this point, you could use the statecode datatype like any other system-supplied type. You could use this type in the table definition, a variable declaration, a stored-procedure parameter definition, etc. For example, to declare a variable called @stateval using your new statecode datatype, you would use the following syntax: DECLARE฀@stateval฀statecode;

A quick word of warning is called for regarding user-defined types. Unlike most artifacts in SQL Server 2008, there is no mechanism to alter any user-defined datatype. The only way to alter the type is to drop and re-create the type. You will not be allowed to drop the type if the type is currently in use in the database. For example, if you were to create a table using the statecode datatype and then decide later that you would prefer to use a three-character abbreviation instead of a two-character abbreviation, the resulting process would be complex. You would have to alter the table to change the statecode type to a different valid type before you could drop your custom type. After dropping and re-creating the statecode type, you could alter the table again to use the new type, but only if the data in the table was compliant with the new type definition. The purpose of custom datatypes is to create a consistent definition that is unlikely to change over time. Do not expect that you will be able to use custom datatypes to establish a single point of change for your datatype definition. Misunderstanding this point can cause significant work by forcing you to reconstruct the database. If you do want to drop the custom datatype, use the following syntax: DROP฀TYPE฀dbo.statecode;

Once a custom datatype is created, you can get information about that type, as well as any system-supplied datatype, by using the sp_help system-stored procedure. This is an extremely useful system-stored procedure for the database administrator and the developer, as it can be used to generate information about a wide range of database artifacts. Figure 2.8 demonstrates the use of this stored procedure for the statecode datatype and shows its results.

Figure 2.8 Getting custom datatype details

You can also get information about your datatypes by using the SQL Server Management Studio. Using the Object Explorer, expand the tree view as illustrated in Figure 2.9. Once you locate your custom type, double-click the name of the type to open the details window as illustrated in Figure 2.10. Note that in this details view you will not be able to make any changes to the structure of the type; this window is read-only.

61

62

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Figure 2.9 Locating the custom type in the Object Explorer

Is There an Easier Way? Although you should get used to using Transact-SQL code for most of your development and administrative duties, the SQL Server Management Studio does provide an interface that you can use to accomplish many of these simple tasks. You can even use this interface to script these artifacts if needed. When you right-click on your custom datatype in the Object Explorer, the options to delete and rename the type will appear. In addition, you will see an option to create a new user-defined datatype along with the option to script an already existing type if needed. Another useful interface feature is the ability to view dependencies. Although the majority of this functionality is available through the Transact-SQL, it is convenient to be able to perform these operations in the interface as opposed to writing code.

THE BOTTOM LINE

|

Figure 2.10 Viewing the details of the custom type

Datatypes are the building blocks of your SQL applications. Getting to know them and learning how to apply them, as well as understanding where they fit into the architectural structure of SQL Server, are critical for success as a SQL Server administrator or developer.

The Bottom Line Apply your understanding of SQL Server internals to implement good logical architecture. It’s not enough to simply understand SQL Server internals; you must also be able to apply the information to the implementation of a stable and extensible architecture. The better you understand how SQL Server works, the more likely you will be to avoid the pitfalls and design problems that often plague the novice administrator. Master It Your SQL Server seems to be running slowly in response to some queries that process large amounts of data. As you investigate the situation more closely, you notice that there is a significant amount of disk activity. There also appears to be a significant amount of LazyWriter activity. Based on your knowledge of SQL Server internals, where should you look next to identify the problem? You should evaluate how much memory you have in your server. If you have over 3GB of RAM, you should check your boot.ini file to see if the /3GB switch is set. This can give you another 1GB of RAM. If you have over 16GB of RAM but the server is not configured to use AWE, you are not getting the benefit of the extra memory. In this case, remove the /3GB switch (if it is set) because this will prevent the server from seeing memory over 16GB. Make sure that the /PAE switch is set in the boot.ini file, enable the Lock Pages in Memory profile setting, and enable AWE in the server configurations.

63

64

| CHAPTER 2

UNDERSTANDING SQL SERVER ARCHITECTURE

Utilize the SQL Server catalog to get more information about the system and your application. All of the information that you need about the SQL Server configurations and settings is available if you know where to go to get it. When properly mined, the SQL Server catalog can provide extensive information that can be invaluable as you diagnose, tune, and maintain your servers. Master It

What SQL query would you use to get the following information?

1. Details on the files used in the AdventureWorks database. 2. A list of all the user tables in the AdventureWorks database. 3. A list of all the user tables and their schema names for the AdventureWorks database. Effectively implement datatypes, including user-defined datatypes. As the foundation for all SQL Server applications, datatypes define how SQL Server will store every piece of information it receives. If this storage is efficient or inefficient, fast or slow to retrieve, or large or small in its storage, you can’t always blame SQL Server. Sometimes it’s up to you to provide appropriate storage definitions. Master It Which of the SQL Server datatypes would you use to store each of the following data values?

1. A United States Postal Service zip code with five digits. 2. The first name of a customer. 3. A memo field that stores freeform comments and may contain a lot of data. 4. The total cost of an order. 5. The date of an order (assuming that you process all orders daily and all orders placed on the same day are treated the same).

Chapter 3

Databases, Files, and Resource Management Creating and managing databases, files, and their resources are required tasks for many administrators and developers working with SQL Server. Before many things can be accomplished with SQL Server, you must create a database to store database objects. In this chapter, we will focus on planning and creating new databases, understanding the options available for database creation, and maintaining databases and their resources on an ongoing basis. In this chapter, you will learn to: •u฀ Create new SQL Server databases •u฀ Discover information about existing databases •u฀ Manipulate database files and filegroups •u฀ Take advantage of database snapshots

Planning a Database Before we can do anything pertaining to a new application using SQL Server, you must create one or more databases. Before you create a new database, it’s important to have a plan for its implementation on the server. This plan can include many things, such as the estimated size of the database, the placement of data files, and the tolerance for data loss. In this section, we’ll examine the mechanics for planning a database and the components and options available for sizing, file placement, and recovery.

Planning for Database Usage When planning a new database, you need to have at least a basic understanding of what information the database will store and how that information will be used. This will enable you to make better decisions about structuring and sizing the database and its files. A database of constantly changing values will need more space available to keep track of modifications than a database that is mostly queried. It is also important for you to understand the server environment that will be hosting the database. You will want to use all of the resources at hand in the most efficient way possible. Understanding reliability and availability expectations is also incredibly important.

66

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

Fully Utilize What You Have! It’s not unusual to come across SQL Servers that are using only a small percentage of the resources they actually have. One example that comes to mind involves servers that have dedicated volumes for database and log files that aren’t used, or are only partially used. When working with a new server that has separate volumes for database and log files, verify that the database files and log files are stored in the appropriate places, and not on the C: drive. The following query displays a list of all databases, with their data and log file locations. SELECT฀DB_NAME(database_id)฀As฀dbname,฀ ฀฀฀฀type_desc,฀ ฀฀฀฀name,฀ ฀฀฀฀LEFT(physical_name,฀2)฀As฀DriveLetter FROM฀sys.master_files;

DATABASE CONCEPT REVIEW A database in SQL Server consists of one or more data files, and at least one transaction log file, and may also include one or more folders designated for FILESTREAM storage. The data files contain the objects and data within the database. The transaction log keeps track of all modifications to a database and is required for recovery in the event of a system failure. When a new database is created, the model system database is used as a template. The database settings on the model are used as the defaults for any new databases created on that server. Any user objects that exist in the model will also exist in all new user databases created on the server. While many databases will contain one data file and one transaction log file, some will contain many files divided into filegroups. Filegroups are named collections of files that allow a database developer to place database objects into specific sets of files. Filegroups can be used to improve performance, as well as aid in the back up and recovery of large databases.

DATABASE STORAGE REQUIREMENTS The size of your database will depend on two things: what you store in it and how much that data is modified. A large amount of space is used by the data files to store all objects in the database. The transaction log is responsible for storing all modifications to data and maintaining transactional integrity. When you are creating a new database, it is important to choose the size of these files appropriately, rather than relying on SQL Server to automatically grow the files as needed.

Planning for Recovery Every database in SQL Server has a recovery model. The recovery model determines if the transaction log will be allowed to accumulate all of the changes made to the database, or only a limited amount of changes for recovery purposes. The recovery model chosen will impact how the database is backed up and how much data loss can be prevented in the event of a failure.

PLANNING A DATABASE

|

UNDERSTANDING RECOVERY REQUIREMENTS In order to choose an appropriate recovery model for a database, it is important to determine its sensitivity to data loss and the availability requirements. Several questions that need to be considered include: •u฀ How much data loss is acceptable? •u฀ Will the database ever need to be restored to a point in time? •u฀ Can the database easily be re-created from other sources? •u฀ How often does the data in the database change? •u฀ How much space is available for backup storage?

The answers to these questions will impact your decisions when choosing a recovery model and backup strategy.

DATABASE RECOVERY MODELS The database recovery model determines if the transaction log is allowed to accumulate all changes to a database, a subset of changes, or only enough changes for database recovery. The recovery model also determines if transaction log backups are required to free space for new transactions. In cases where recovery to the last full backup is acceptable, the transaction log can be set to automatically truncate every time a new checkpoint occurs, freeing up log space. There are three database recovery models: Full, Simple, and Bulk-Logged. In the following text, we will explore the characteristics of each model. Full Recovery When using the full recovery model, the transaction log accumulates all changes made to the database. To keep a record of all modifications, the transaction log is periodically backed up. If the transaction log isn’t backed up, the log will continue to accumulate changes until no more space is available. Therefore, a log backup strategy is very important. For most installations of SQL Server, this is the default recovery model. Simple Recovery When using the simple recovery model, the transaction log accumulates enough information to recover the database in the event of a system failure. Transactions are periodically truncated from the transaction log to free up disk space and shorten the recovery time. When a database is using the simple recovery model, only full and differential backups are allowed. Transaction log backups are not used. Therefore, restoring the database is only possible up to the last full or differential backup. Simple recovery is most appropriate for databases that can easily be re-created in the event of a hardware failure, and where a certain amount of data loss is acceptable. Bulk-Logged Recovery The bulk-logged recovery model is similar to the full recovery model, but in it less information about certain bulk operations is written to the transaction log. An advantage of this model is that less space is used for bulk operations, thereby minimizing the amount of space required for backups. Because less information is logged about these operations, only full transaction log backups can be restored; point-in-time recovery is not supported.

67

68

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

As we mentioned, the default recovery model for a new database on SQL Server is full. However, you can change the default recovery model for new databases by changing the recovery model of the model system database. To view the recovery models of all user databases on a SQL Server instance, use the following query: SELECT฀name,฀recovery_model_desc฀FROM฀sys.databases;

The recovery model may be changed by modifying the properties of the database in Management Studio, or by using the ALTER฀DATABASE statement. To change the recovery model using SQL Server Management Studio, right-click on the database and choose Properties. You can change the recovery model on the Options page. The syntax for changing the recovery model using the ALTER฀DATABASE statement is as follows: ALTER฀DATABASE฀databasename฀ ฀฀SET฀RECOVERY฀{฀SIMPLE฀|฀FULL฀|฀BULK_LOGGED฀};

When changing the recovery model, be sure to perform a full database backup to begin the transaction log chain.

Capacity Planning When you are creating a new database on SQL Server, it is important to have an idea of how much space to allocate. A good practice is to allocate as much space as possible to avoid costly Autogrowth operations as data is loaded into the database. In situations where table structures, row counts, and index structures are known ahead of time, Books Online provides good documentation on estimating the amount of space that will be taken up in the database files by each object.

DATA AND LOG FILE PLACEMENT It is important to place your database and log files in appropriate locations to maximize performance and improve recoverability. Placing the database and log files on separate volumes improves performance by separating I/O operations. Database files are best placed on disks with high read and write performance. Another important aspect to consider when placing database files is fault tolerance. RAID (Redundant Array of Independent Disks) is a commonly used component in SQL Server. There are several RAID levels available: RAID 0: Disk Striping In RAID 0, data is striped among all of the disks in a set. High performance is achieved because multiple disks are able to handle operations in parallel. Fault tolerance isn’t provided by this RAID level, and RAID 0 isn’t generally used by itself in database operations for this reason. RAID 0 can be combined with RAID 1 for fault tolerance and improved performance RAID 1: Disk Mirroring/Disk Duplexing In RAID 1, data is mirrored to two different disks simultaneously. This provides a separate, redundant copy of all data with very little performance degradation in the event of a failure. This option is a fantastic choice for transaction log storage, because data is generally written to only one area of the transaction log at a time. RAID 5: Disk Striping with Parity RAID 5 provides a fault-tolerant storage mechanism but does not need as much disk space as storing a completely separate copy of the data. Fault tolerance is provided using parity calculations.

CREATING DATABASES

|

RAID 1+0 (or 0+1): Disk Mirroring with Striping RAID 1+0 (or 0+1) is excellent in terms of fault tolerance and performance. However, it is fairly expensive in terms of actual storage space used. While RAID 5 is commonly used for database file storage, keep in mind that parity calculations will impact some of the performance gained by striping the data across several disks.

PLANNING MULTIPLE FILEGROUPS Database files can be grouped into filegroups for performance and administrative reasons. Filegroups allow an administrator to control the placement of a database object, such as a table or index, into a set of data files. Filegroups also perform the following functions: •u฀ Allow I/O operations for heavily used tables and indexes to be focused on a specific disk

or array. •u฀ Enable individual database files to be backed up separately from the rest of the database. •u฀ Enable piecemeal restore, which lets you bring different pieces of the database online in

phases during disaster recovery. Piecemeal restore will be covered in more depth in Chapter 9, “Data Recovery.” •u฀ Separate read-only data from the rest of the database.

The primary filegroup exists in every database on SQL Server. The primary filegroup contains all data files that haven’t been specifically assigned to a user-defined filegroup, and it is the default filegroup for new database objects. If the primary filegroup becomes full, no other data files can expand, because the primary filegroup contains all of the system tables. For this reason, it is recommended that a user-defined filegroup be set as the default for creating new database objects. Here are some more hints for using filegroups: •u฀ Most databases work well with a single data file and a single transaction log file. Make sure

you have clear reasons for using additional filegroups in a database. •u฀ When using multiple files, creating an additional filegroup and setting that filegroup to be

the default will allow isolation of the system tables from the rest of the database objects. Make sure to size each file appropriately. •u฀ Creating filegroups on as many disks and RAID arrays as possible will provide the best

performance. •u฀ Placing tables and indexes into separate filegroups on separate volumes can improve query

performance. In the next section, we will explore how to create databases with multiple filegroups.

Creating Databases Creating a database is a fairly simple step, assuming you have gathered the appropriate information. There are several methods for creating a database including using Transact-SQL, Management Studio, or SQL Server Management Objects (SMO). Specifying appropriate file loca-

69

70

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

tions, sizes, and growth increments is critical to the performance of the database. Depending on the complexity of the database, you also may need to create the appropriate filegroups. Several script templates are available in the Template Explorer within Management Studio for creating databases. You may also use the Script button at the top of the Create Database window to script out the creation statements based on what was configured in the user interface.

Creating the Database You can create a new database using either Management Studio or Transact-SQL. When you create a new database, you must specify a name for the database, logical and physical names for each file, and size information for each file. A file may use Autogrowth to automatically grow by a percentage or number of megabytes until it reaches a maximum size. Make sure to specify large Autogrowth increments so that the database doesn’t need to grow very often, because this can be an expensive process. The following example shows how to create a new database named SimpleDB with a single database file and single transaction log file. To create a new database using Management Studio, perform the following steps:

1. Open SQL Server Management Studio and connect the Object Explorer to the database engine on SQL Server where you want to create the database.

2. Right-click the Databases folder and select New Database. The dialog shown in Figure 3.1 appears.

Figure 3.1 The New Database window

3. Enter the name for the new database in the Database Name text box. 4. If the database will contain user-defined filegroups, select the Filegroups page and add the appropriate filegroup names. Switch back to the general page.

CREATING DATABASES

5. Configure the properties for each data and log file by filling in the appropriate information under Database Files.

a. Set an initial size that will accommodate the information contained in each file. b. Set the Autogrowth and Maximum File Size properties for each file by clicking on the ellipsis in the Autogrowth column. The dialog is shown in Figure 3.2.

Figure 3.2 The Change Autogrowth window

c. Choose an appropriate path and filename for each file. 6. To add additional data files, click the Add button at the bottom of the window and fill out the appropriate options for the file.

7. Select the Database Options section, and configure the recovery model and other database options, which are covered in detail later in the chapter.

8. Click the OK button to create the new database. Transact-SQL can also be used to perform the same operations as Management Studio. For many operations, including creating databases, a script can be generated using the Script button at the upper-left area of the Create Database window. After the script is generated, you can click the Cancel button to allow you to view, change, and execute the code. The example in Listing 3.1 creates a database named SimpleDB with a single database file and log file. In order to run the following examples, you must create the directories C:\SQL\ DataFiles and C:\SQL\LogFiles.

Listing 3.1

Creating a New Database Using Transact-SQL

CREATE฀DATABASE฀SimpleDB ON฀PRIMARY฀( ฀฀฀NAME฀=฀SimpleDB, ฀฀฀FILENAME฀=฀‘C:\SQL\DataFiles\SimpleDB.mdf’, ฀฀฀SIZE฀=฀10MB, ฀฀฀MAXSIZE฀=฀20MB, ฀฀฀FILEGROWTH฀=฀5MB) LOG฀ON฀( ฀฀฀NAME฀=฀SimpleDB_Log,

|

71

72

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

฀฀฀FILENAME฀=฀‘C:\SQL\LogFiles\SimpleDB.ldf’, ฀฀฀SIZE฀=฀2MB, ฀฀฀MAXSIZE฀=฀10MB, ฀฀฀FILEGROWTH฀=฀10%);

Another common situation is to create a database with multiple filegroups. The example in Listing 3.2 creates a database with a user-defined filegroup named UserFG, and sets the UserFG filegroup to be the default for new objects.

Listing 3.2

Creating a New Database with Multiple Filegroups Using Transact-SQL

CREATE฀DATABASE฀FileGroupDB ON฀PRIMARY฀(฀ ฀฀฀NAME=’FGDB_Primary’, ฀฀฀FILENAME=’C:\SQL\DataFiles\FileGroupDB.mdf’, ฀฀฀SIZE=5MB, ฀฀฀MAXSIZE=10MB, ฀฀฀FILEGROWTH=1MB), FILEGROUP฀UserFG฀(฀ ฀฀฀NAME=’UserFG_data1’, ฀฀฀FILENAME=’C:\SQL\DataFiles\FileGroupDB_UserFG.ndf’, ฀฀฀SIZE=5MB, ฀฀฀MAXSIZE=10MB, ฀฀฀FILEGROWTH=1MB) LOG฀ON฀( ฀฀฀NAME=’FGDB_log’, ฀฀฀FILENAME=’C:\SQL\Logfiles\FileGroupDB.ldf’, ฀฀฀SIZE=5MB, ฀฀฀MAXSIZE=10MB, ฀฀฀FILEGROWTH=1MB); GO ALTER฀DATABASE฀FileGroupDB฀ ฀฀MODIFY฀FILEGROUP฀UserFG฀DEFAULT; GO

UNDERSTANDING FILESTREAM STORAGE Filestream storage is a new feature of SQL Server 2008 that integrates the database engine with the NTFS file system. Data that is stored in a column that is defined as FILESTREAM can be accessed by retrieving a file handle and using that file handle with Win32 API calls. Columns using the varbinary(max) data type with the FILESTREAM column attribute can provide access to the data using traditional methods or as files on the file system. Applications may modify the files as needed, while continuing to maintain transactional consistency.

CREATING DATABASES

For small amounts of data, better performance may be achieved if you can access them directly through the database streaming interfaces. To determine if you should consider using FILESTREAM storage, ask the following questions: •u฀ Are the files to be stored larger than one megabyte on average? •u฀ Is fast, flexible read access important? •u฀ Are you developing applications that use a middle tier for application logic?

To use FILESTREAM storage, you must enable FILESTREAM for the instance, create a filegroup to store FILESTREAM data, and create a table that contains a varbinary(max) column with the FILESTREAM attribute. To enable FILESTREAM for an instance, use the SQL Server Configuration Manager tool. To access the dialog shown in Figure 3.3, you must right-click on your SQL Server instance, choose Properties, and choose the FILESTREAM tab. In order to access the files from a remote computer, you must enable FILESTREAM for file I/O streaming access and allow remote clients to have streaming access to FILESTREAM data.

Figure 3.3 Configuring FILESTREAM

Once you’ve enabled FILESTREAM at the instance level, you can then create a new database or alter an existing database to use FILESTREAM by creating a filegroup that specifies a path for storing FILESTREAM data. Listing 3.3 uses the C:\SQL\FILESTREAMData folder for storing data. This folder must not exist when creating the filegroup.

Listing 3.3

Creating a Database with a FILESTREAM Filegroup

CREATE฀DATABASE฀FileStreamDB฀ON฀PRIMARY ฀฀(฀NAME฀=฀FileStreamDB_data,฀ ฀฀฀FILENAME฀=฀‘C:\SQL\DataFiles\FileStreamDB_data.mdf’, ฀฀฀SIZE฀=฀10MB, ฀฀฀MAXSIZE฀=฀50MB,฀ ฀฀฀FILEGROWTH฀=฀15%),

|

73

74

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

FILEGROUP฀FileStreamData฀CONTAINS฀FILESTREAM ฀฀(฀NAME฀=฀FileStreamData,฀ ฀฀฀FILENAME฀=฀‘C:\SQL\FileStreamData’) LOG฀ON฀ ฀฀(฀NAME฀=฀‘FileStreamDB_log’,฀ ฀฀฀FILENAME฀=฀‘C:\SQL\LogFiles\FileStreamDB_log.ldf’, ฀฀฀SIZE฀=฀5MB,฀ ฀฀฀MAXSIZE฀=฀25MB,฀ ฀฀฀FILEGROWTH฀=฀5MB); GO

To store data using FILESTREAM, you must create a table that contains a unique ROWGUID column that doesn’t allow NULL values, as well as a column using the varbinary(max) datatype with the FILESTREAM column attribute. Listing 3.4 shows an example of creating a table that contains a FILESTREAM column and inserting a row.

Listing 3.4

Creating a Table with a FILESTREAM Column and Inserting Data

USE฀FileStreamDB; GO CREATE฀TABLE฀FileStreamTable (FileStreamID฀UNIQUEIDENTIFIER฀ROWGUIDCOL฀NOT฀NULL฀UNIQUE,฀ ฀฀FileStreamData฀varbinary(max)฀FILESTREAM฀NOT฀NULL); GO INSERT฀INTO฀FileStreamTable฀ VALUES฀(NEWID(),฀CAST(‘FileStreamData’฀As฀VarBinary(max)))

To access data using the file system, you must use the PathName() function to retrieve a file path, and use the GET_FILESTREAM_TRANSACTION_CONTEXT() function to retrieve a transaction context for use in your application code. Listing 3.5 shows an example of using the PathName function to retrieve the file path.

Listing 3.5

Retrieving the Path of FILESTREAM Data Using the PathName Function

SELECT฀FileStreamID,฀FileStreamData.PathName() ฀฀FROM฀FileStreamData;

For detailed information on using the FILESTEAM feature in your applications and the Win32 API calls used, see Books Online.

CREATING DATABASES

|

Manipulating Database Options Many database options are available (see Figure 3.4). Most of them are set soon after a database is created and aren’t generally changed on a regular basis. Understanding how they affect the different areas of functionality in a database is very important.

Figure 3.4 The Database Options window

AUTOMATIC OPTIONS Here are some of the several automatic options available for each database. Auto Close (AUTO_CLOSE) Controls if the database and resources are closed after the last user disconnects. The default is OFF for all editions except for SQL Server Express Edition. Turning this on can degrade performance for production databases. Auto Shrink (AUTO_SHRINK) This option controls if database files are automatically shrunk at 30-minute intervals and space released when more than 25 percent of the database contains unused space. By default, auto shrink is turned off. This option should be used with caution, due to its database-locking behavior and the possibility that an increase in database size will cause the database files to grow again. A better alternative to using this option is to schedule a shrink operation using the steps detailed later in this chapter. Index statistics are used by the query optimizer to determine information about the distribution of values within a column. Index statistics and query optimization will be discussed further in Chapter 14, “Indexing Strategies for Query Optimization.” Auto Create Statistics (AUTO_CREATE_STATISTICS) By default, this option is turned on, and any missing statistics are built during query optimization.

75

76

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

Auto Update Statistics (AUTO_UPDATE_STATISTICS) When this option is on, any outof-date statistics are rebuilt during query optimization. Any query that requires a statistics update will wait for the update operation to complete before results are returned. Auto Update Statistics Asynchronously (AUTO_UPDATE_STATISTICS_ASYNC) This option allows asynchronous updates to happen. When it is enabled, queries will not wait for statistics to be updated before compiling.

CURSOR OPTIONS Cursors allow Transact-SQL statements to be executed for each row in a result set. At the database level, several cursor options are available to control their behavior. Close Cursor On Commit Enabled (CURSOR_CLOSE_ON_COMMIT) When this option is set to TRUE, an open cursor is closed automatically when a transaction is committed or rolled back. The ANSI SQL-92 specification expects this behavior, but the default for this option is FALSE. Cursors remain open across multiple transactions and close only when the cursor is explicitly closed, or the connection is closed. Default Cursor (CURSOR_DEFAULT) The possible settings for this option are GLOBAL and LOCAL. The default is to use global cursors, meaning that a cursor not explicitly declared as local may be referenced in any stored procedure, trigger, or batch that the connection executes.

MISCELLANEOUS OPTIONS These options control ANSI-compliance behaviors and external access to the database. Two new options worth noting are Date Correlation Optimization and Parameterization options. Date Correlation Optimization Enabled (DATE_CORRELATION_OPTIMIZATION) When this option is set to TRUE, SQL Server maintains correlation statistics between any two tables in the database that are linked by FOREIGN KEY constraints and have datetime columns. By default, this option is set to FALSE. Parameterization (PARAMATERIZATION) This option determines if queries are parameterized based on behavior of previous versions of SQL Server, or if forced parameterization is used. Forced parameterization can benefit databases that execute many concurrent queries without explicit parameterization used. The default is to use SIMPLE parameterization. Options that are carried over from prior releases include: ANSI NULL Default (ANSI_NULL_DEFAULT) This option determines if a column in a CREATE฀TABLE statement that doesn’t specify nullability will be specified as NULL or NOT NULL by default. When set to TRUE, columns that don’t specify nullability will allow null values. ANSI NULLS Enabled (ANSI_NULLS) This option determines if any value ever equals NULL. When doing comparisons for NULL values, it is best to use IS NULL. If this option is set to TRUE, comparisons to null are allowed to match values. ANSI Padding Enabled (ANSI_PADDING) This option determines if trailing blanks will be padded to the full length of varchar and nvarchar columns. By default, ANSI Padding Enabled is set to FALSE.

CREATING DATABASES

|

ANSI Warnings Enabled (ANSI_WARNINGS) This option determines if additional warnings are displayed, such as divide by zero, that would otherwise not be displayed. By default, ANSI Warnings is set to FALSE. Arithmetic Abort Enabled (ARITHABORT) When this option is set to TRUE, any query that results in an overflow or divide-by-zero error is terminated, and an error message is displayed. The default for this option is FALSE, which will result in only a warning message for these situations. Concatenate Null Yields Null (CONCAT_NULL_YIELDS_NULL) When this option is set to TRUE, concatenating a NULL value to a string results in a NULL value. By default, this option is set to FALSE, and the NULL value is treated as an empty string. Cross-Database Ownership Chaining Enabled (DB_CHAINING) This option controls if the database can be the source or target of a cross-database ownership chain. This setting is only recognized when the Cross DB Ownership Chaining server option is set to 0 (OFF); otherwise all databases on the instance can participate in cross-database ownership chaining. Numeric Round-Abort (NUMERIC_ROUNDABORT) When this option is set to TRUE, any expression that results in a loss of precision generates an error. By default, this option is set to FALSE, and losses of precision do not generate error messages. The result is rounded to the precision of the column storing the result. Quoted Identifiers Enabled (QUOTED_IDENTIFIER) This option determines if strings surrounded by double quotes are treated as object identifiers, or as string literals. By default, this option is set to FALSE, and items surrounded by double quotes are treated as string literals. When true, items in double quotes are treated as object identifiers. Note that regardless of this setting, square brackets can always be used to delimit an object identifier. Recursive Triggers Enabled (RECURSIVE_TRIGGERS) This option controls if a trigger defined on a table that modifies itself can cause the same trigger to fire again. By default, this option is set to FALSE. Trustworthy (TRUSTWORTHY) This option determines if stored procedures and userdefined functions can use an impersonation context to access resources outside of the database. By default, stored procedures and user-defined functions executing in an impersonation context cannot access resources outside of the database.

RECOVERY OPTIONS The two database recovery options are the database recovery model discussed earlier and the Page Verify option. The Page Verify option controls the type of verification method used when reading and writing pages to disk. There are three possible options to select for Page Verify: CHECKSUM When Page Verify is set to this, checksums are used to find incomplete page writes caused by disk I/O errors. The checksum is computed over the entire contents of the data page and stored in the page header when it is written to disk. When the page is subsequently read from disk, the checksum is recomputed and compared to the value stored in the page header. If there is a mismatch, error message 824 is raised. Any I/O errors detected by the operating system are logged using error message 823.

77

78

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

TORN_PAGE_DETECTION When Page Verify is set to this, a bit is reversed for each 512byte sector in a database page when the page is written to disk. If the bit is in the wrong state when the page is later read, the page was written incorrectly, and a torn page is detected. NONE When Page Verify is set to this, future data pages written won’t use checksums or reserved bits, and pages will not be verified when read, even if checksums or reserved bits exist.

STATE OPTIONS This category contains options that control aspects of the database state. These include: Database Read-Only This option determines if the database is considered read only. Changing this option affects the database state. Encryption Enabled (ENCRYPTION) This option determines if transparent data encryption is enabled. Data encryption is covered in detail in Chapter 13, “SQL Server Data Security.” Restrict Access (MULTI_USER, SINGLE_USER, RESTRICTED_USER) The default access restriction for a database is MULTI_USER, which allows all users with appropriate permissions to access the database. When this option is set to SINGLE_USER, only the database owner can access the database. When this option is set to RESTRICTED_USER, only members of the db_owner, dbcreator, or sysadmin roles can access the database. More detailed discussion of manipulating database and file states is covered in the next section.

Managing Databases, Files, and Filegroups Managing a database and its files has many aspects. This section will provide the how and why of each of the operations you will likely encounter. Nearly all of these operations can be performed using Management Studio or Transact-SQL.

Altering a Database Altering a database allows us to change many aspects of the database after it has been created. This may involve changing database-level options, expanding data or log files, or even adding additional files. Most of the changes made to the database’s Properties window (Figure 3.5) in Management Studio results in an ALTER฀DATABASE statement being generated. Always remember that you can script the changes you have made in the Database Properties window using the Script button at the top.

CHANGING DATABASE AND FILE STATES A database is always in a single state, hopefully ONLINE most of the time. Other common database states include OFFLINE, RESTORING, SUSPECT, or EMERGENCY. You can view the current state of the databases on a SQL Server by querying the state_desc column of the sys. databases catalog view. Management Studio allows you to take a database offline or bring it back online by right-clicking on the database and viewing the Tasks submenu. You may also use the following syntax: USE฀master; ALTER฀DATABASE฀SimpleDB฀SET฀[฀OFFLINE฀|฀ONLINE฀];

MANAGING DATABASES, FILES, AND FILEGROUPS

Figure 3.5 The Database Properties window

A database may be put into EMERGENCY state for troubleshooting. By setting a database to the EMERENCY state, the database is marked read only, and access is limited to members of the sysadmin server role. A database marked as SUSPECT can be changed to the EMERGENCY state to allow an administrator to further examine the data that is available. A database can be observed in the RESTORING state when a restore is taking place, and there are more backups to be applied. Backup and Restore operations will be discussed further in Chapter 9. Individual files also have a state tracked independently of the database. The state of individual database files may be viewed by querying the sys.database_files or sys.master_files catalog views. Use caution when setting a file to the OFFLINE state, as the file may only be set online by restoring that file from a backup.

CHANGING DATABASE FILE LOCATIONS Sometimes, you will encounter databases that have files in inappropriate locations. As a consultant, I’ve seen many databases with files residing on the system drive of the SQL Server, even when better locations are available. Moving these database files involves taking the database offline until the files are moved into their new location. Keep in mind that the following procedure is intended for locations on the same server. To move one or more files for a user database to a different location, use the following steps:

1. Take the user database offline: ALTER฀DATABASE฀db_name฀SET฀OFFLINE;

|

79

80

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

2. Move the files to a new location. 3. For each file that was moved, run the following code: ALTER฀DATABASE฀db_name ฀฀MODIFY฀FILE฀( ฀฀฀NAME฀=฀logical_name ฀฀฀FILENAME฀=฀‘X:\Path\File.Name’฀);

4. Bring the user database back online: ALTER฀DATABASE฀db_name฀SET฀ONLINE;

The steps for moving most of the system databases are similar, with the exception of the master database. Please refer to Books Online for the process of moving system databases.

ATTACHING AND DETACHING DATABASES The attach and detach features allow you to move or copy databases between instances and servers, as well as remove a database from an instance without deleting the associated data and log files. Detaching a database removes references to the database from the master system database, but does not delete database or log files. After a database has been detached, the associated files can be moved or copied to their new location, and attached. Attaching a database adds a reference to the database and associated files to the master database on the SQL Server instance. Before detaching a database, verify that the following conditions have been met: •u฀ No database snapshots exist for the database about to be detached. (Database snapshots are

covered in more detail later in the chapter.) •u฀ The database is not being mirrored. •u฀ The database is not being replicated. •u฀ The database is not marked as suspect. (In order to detach a suspect database, you must

first put the database into EMERGENCY mode. For more information, see the “Changing Database and File States” section earlier in this chapter.) Detaching a database may be accomplished using SQL Server Management Studio, or by using the sp_detach_db system stored procedure. To detach a database using SQL Server Management Studio, follow these steps:

1. Open SQL Server Management Studio, and in the Object Explorer view, connect to the server that contains the database you would like to detach. Expand the Databases folder, and find the database to detach.

2. Right-click on the database, and choose Tasks  Detach from the context menu. 3. In the Detach Database window (shown in Figure 3.6), choose the appropriate options: •u฀ The Drop Connections checkbox will drop all connections to the database before per-

forming the drop operation.

MANAGING DATABASES, FILES, AND FILEGROUPS

•u฀ The Update Statistics checkbox is equivalent to setting the skipchecks parameter of

sp_detach_db to TRUE. Updating statistics makes the database easier to use with read-only media, otherwise you don’t need the update. •u฀ The Keep Full Text Catalogs checkbox is equivalent to the KeepFulltextIndexFile

parameter of the sp_detach_db system stored procedure. By default, full text indexes are maintained as a part of the database.

Figure 3.6 The Detach Database dialog

Attaching a database may be accomplished in several ways. Using the CREATE฀DATABASE฀ FOR฀ATTACH syntax is the recommended way. The system stored procedure sp_attach_db is provided for backward compatibility, and it will be removed in a later version of SQL Server. To attach a database using SQL Server Management Studio, follow these steps:

1. Open SQL Server Management Studio, and in the Object Explorer view, connect to the server that you would like to attach the database to.

2. Right-click the Databases folder, and choose Attach from the context menu. 3. In the Attach Databases window (shown in Figure 3.7), click the Add button, and choose the primary data file of the database you would like to attach.

4. Verify that any secondary database files and log files are in the appropriate paths. 5. Click OK to attach the database.

|

81

82

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

Figure 3.7 The Attach Database window

Growing and Shrinking Databases and Files Database file size needs to be maintained over time. File size can be maintained automatically using database features such as automatic growth and auto shrink. The automatic growth and auto shrink options are covered earlier in this chapter under the section setting database options. In many cases, greater control over database and file size is needed than the automatic options provide. In order to provide this control, database and file sizes can be managed manually. This section will examine the methods for manually managing database and file sizes by using SQL Server Management Studio and by executing Transact-SQL statements.

INCREASING THE SIZE OF A DATABASE Manually increasing the size of a database is a simple process. You may increase the size of existing files or add new secondary data files to a database in order to increase the size. Adding additional database files allows a database to expand across several volumes. Instead of writing all the data to the first file until it is full, SQL Server fills each file in a filegroup proportionally to the amount of free space in the file. When all database files are full, each data file in the filegroup is expanded in a round-robin manner. To increase the size of a database using Management Studio, use the following steps:

1. Open SQL Server Management Studio, and in the Object Explorer view, connect to the server that contains the database you would like to manage. Work your way down to the Databases folder.

MANAGING DATABASES, FILES, AND FILEGROUPS

|

2. Right-click the database you would like to modify and select Properties from the shortcut menu.

3. Choose the Files page from the upper-left corner of the window. 4. Make the required changes as follows: •u฀ To expand existing files, change the Initial Size (MB) to a larger number. •u฀ To add a new database file, click the Add button at the bottom of the screen, and fill

out the required information for the new file, including the initial size and location.

5. Click the OK button to make the change. When changing the size of a database file using the Database Properties window, the size may only be increased beyond the current size. Inputting a value smaller than the current size will result in an error. The process for shrinking database files is covered later in this chapter. Database files’ properties may also be changed using the ALTER฀DATABASE Transact-SQL statement. The Transact-SQL statements in Listing 3.6 increase the size of the TestDB_Primary device to 50 megabytes, and add a secondary database file to the TestDB database:

Listing 3.6

Manipulating Database Files

ALTER฀DATABASE฀SimpleDB ฀฀MODIFY฀FILE฀( ฀฀฀NAME=SimpleDB, ฀฀฀SIZE=100MB฀) GO ALTER฀DATABASE฀SimpleDB ฀฀ADD฀FILE฀( ฀฀฀NAME=SimpleDB_Secondary, ฀฀฀FILENAME=’C:\SQL\DataFiles\SimpleDB_Secondary.ndf’, ฀฀฀SIZE=50MB, ฀฀฀MAXSIZE=100MB, ฀฀฀FILEGROWTH=25MB฀);

When modifying existing files, other attributes such as MAXSIZE and FILEGROWTH can also be modified for each file. To verify that your changes have occurred, you can query the sys.database_files catalog view.

SHRINKING DATABASES AND DATABASE FILES As data is removed from a database, the space used remains allocated to the database files. Shrinking a database allows free space that is no longer used by a file to be released to the operating system. Leaving adequate space for growth in a database is important. If you don’t expect the database to reclaim the available space in the near future, it is best not to shrink it. Excessive shrinking of a database can lead to file fragmentation, and to an increased number of automatic growth operations if the database is configured for automatic growth.

83

84

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

To shrink an entire database, use these steps:

1. Open SQL Server Management Studio, and connect the Object Explorer to the server that contains the database you would like to shrink. Expand the Databases folder.

2. Right-click the database you would like to shrink, and select Tasks  Shrink  Database from the context menu to display the Shrink Database dialog shown in Figure 3.8.

Figure 3.8 The Shrink Database dialog

3. Examine the amount of currently allocated space and available free space to determine if you really want to shrink the database.

4. To reorganize the data pages and move them to the beginning of the file, select the Reorganize Files Before Releasing Unused Space checkbox. Leaving this checkbox cleared is equivalent to using the DBCC฀SHRINKDATABASE statement with the TRUNCATEONLY option, meaning the size is reduced without moving any data.

5. If the Reorganize Files Before Releasing Unused Space checkbox is selected, you may specify the maximum percent of free space remaining in the database files.

6. Click OK to begin the shrink operation. To shrink an individual database file, use these steps:

1. Open SQL Server Management Studio, and connect the Object Explorer to the server that contains the database with the files you would like to shrink. Expand the databases folder.

MANAGING DATABASES, FILES, AND FILEGROUPS

|

2. Right-click on the database with the file you would like to shrink, and select Tasks  Shrink  Files from the context menu to show the Shrink File dialog shown in Figure 3.9.

Figure 3.9 The Shrink File dialog

3. Select the file you would like to shrink using the File type, Filegroup, and Filename menus. Examine the amount of currently allocated space and available free space to verify the action you are taking.

4. Choose the appropriate shrink action: Release Unused Space Truncates free space from the end of the file without moving data pages. This is equivalent to using the DBCC SHRINKDATABASE฀with TRUNCATEONLY statement. Reorganize Pages Before Releasing Unused Space Reorganizes data pages by moving them to the beginning of the file. After selecting this option, you may select the desired file size in the Shrink File To selection area. This is equivalent to using the DBCC฀SHRINKFILE statement and specifying the amount of free space you would like left in the target file. Empty File (By Migrating the Data to Other Files in the Same Filegroup) Migrates the data contained in the data file to other files in the same filegroup. This is equivalent to using the DBCC฀SHRINKFILE฀with฀EMPTYFILE option. This operation prepares the file to be removed with an ALTER฀DATABASE statement.

5. Click the OK button to begin the Shrink File operation. To shrink a database file using Transact-SQL, use the DBCC฀SHRINKFILE command. To shrink a database using Transact-SQL, use the DBCC฀SHRINKDATABASE command.

85

86

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

Creating Database Snapshots A database snapshot is a read-only, static view of a database. Database snapshots were introduced in the Enterprise edition of SQL Server 2005. A database snapshot can use considerably less space than a separate read-only copy of a database. Database snapshots work by capturing changes as they are made to the source database. Only the modified page values are stored in the files used for the database snapshot. This process is accomplished using sparse files and copy-on-write technology present in the NTFS file system. As the source database’s pages are modified, SQL Server saves the original data pages in a sparse file using a copy-on-write process. This ensures that only changed database pages take up physical space on disk for the snapshot, and this can considerably reduce the amount of storage used in comparison to a separate, read-only copy of a database. The amount of storage needed can very significantly based on the age of the snapshot and the volume of changed data in the source database. Some common scenarios for using database snapshots include: •u฀ Maintaining historical data for reporting purposes •u฀ Using a mirrored database created for availability purposes for reporting •u฀ Protecting data against administrative or user error •u฀ Managing a consistent test environment where changes can easily be rolled back

Database snapshots can introduce some important limitations on the source database as well as the snapshot itself. •u฀ Performance is reduced due to increased I/O from the copy-on-write operation that occurs

when data pages are modified. •u฀ The source database may not be dropped unless all snapshots are also dropped. •u฀ The database snapshot must reside on the same instance as the source database. •u฀ Database files must be stored on an NTFS partition.

CREATING A DATABASE SNAPSHOT In order to create a database snapshot, you must use the Transact-SQL CREATE฀DATABASE…AS฀ SNAPSHOT฀OF statement. While you can view database snapshots in SQL Server Management Studio, you cannot create snapshots from within the user interface; you must use Transact-SQL. When creating a new snapshot, you must specify a new path and filename for the logical name of every database file of the source database. The example shown in Listing 3.7 creates a snapshot of the AdventureWorks database. Note that because snapshots are read only, o log file is specified. All logical database files must be specified, or an error will result.

MANAGING DATABASES, FILES, AND FILEGROUPS

Listing 3.7

Creating a Snapshot of the AdventureWorks Database

CREATE฀DATABASE฀AdventureWorks_ss0800฀ ON฀(฀ ฀฀NAME฀=฀AdventureWorks2008_Data,฀ ฀฀FILENAME฀=฀‘C:\SQL\DataFiles\AdventureWorks_data_0800.ss’฀) AS฀SNAPSHOT฀OF฀AdventureWorks2008;

MANAGING DATABASE SNAPSHOTS After creating a database snapshot, it may be queried like a normal database. When examining the properties of each snapshot file using Windows Explorer, it is important to note that the reported size and size on disk are different, as shown in Figure 3.10.

Figure 3.10 Windows Explorer file properties of a database snapshot

An alternative method to view the actual space used for a file in a database snapshot is to use the fn_virtualfilestats฀table-valued function, and examine the BytesOnDisk column. The maximum size of a database snapshot can be viewed by querying either the sys.database_ files or sys.master_files catalog views. Dropping a database snapshot is similar to dropping a database. A database may be quickly reverted to the state stored in a snapshot by issuing a RESTORE฀ DATABASE…FROM฀SNAPSHOT command as shown in Listing 3.8, so long as only one snapshot of the database exists.

|

87

88

| CHAPTER 3

DATABASES, FILES, AND RESOURCE MANAGEMENT

Listing 3.8

Reverting to a Database Snapshot

RESTORE฀DATABASE฀AdventureWorks2008 ฀฀FROM฀DATABASE_SNAPSHOT฀=฀AdventureWorks_ss0800;

A successful revert operation will automatically rebuild the transaction log, so it is recommended that a transaction log backup be taken before a revert operation.

The Bottom Line Create new databases. Creating new databases is a common and fundamental operation. Understanding what happens when a new database is created is a critical step. Master It What system database is used as a template when creating a new database on SQL Server? How could you create an object that would exist in any new database on the SQL Server? Plan databases. Adequate planning for user databases is very important. From choosing the appropriate recovery model to properly placing files, these choices will prepare the database for future operations. Master It What is the most appropriate recovery model for a mission-critical database that needs the ability to restore to a point in time? Discover information about existing databases. There are many ways to retrieve information about existing databases and their files. Management Studio can be an easy place to view information about individual database options; however, it’s important to remember that this information can be retrieved using system catalog views. Master It What catalog view displays information about every database and database file on the server, including sizes and file options?

Chapter 4

Tables and CRUD Operations Now that you have seen how to create and manage databases and files, it’s time to take the next step and actually put something in the database. Obviously, a database is a big container—that’s all, a container just begging for something to be put inside. Generally, we put two kinds of artifacts into a database: tables and indexes. All of the other artifacts (such as stored procedures, functions, and views) are actually stored in system table structures. A table is the most fundamental component that you will work with in SQL Server. Tables, however, are just containers, and the ultimate goal is to get data into the tables for storage and then manipulate that data at will. The table defines the structure that you will use to store the data, and the Data Manipulation Language (DML) code will give you the power to make that data do anything you like. CRUD stands for Create, Read, Update, and Delete, which is essentially the full range of what you will be able to do with your data. In this chapter, you will learn to: •u฀ Plan and implement appropriate normalization strategies •u฀ Design and create tables using all of the SQL Server table features •u฀ Write simple to complex SELECT statements for returning data to the client •u฀ Perform data modification operations using the INSERT, UPDATE, DELETE, and MERGE SQL

DML statements

Designing Data Storage In 1970 when E. F. Codd released his famous paper, “A Relational Model of Data for Large Shared Data Banks,” the database world began to slowly change forever. By the early 1980s, relational database design became more fashionable. Today, we almost take it for granted. With the host of benefits that relational design can bring to a large database management system, relational design today is the assumption rather than the exception. Still, if you ask two database developers for their definitions of what constitutes a relational database, you will probably get two different answers—maybe even three! Relational data structure has its advantages and disadvantages, but today it is generally accepted as the preferred model for large-scale data storage and manipulation. The most fundamental advantage is that it eliminates data redundancy without sacrificing the “any data anywhere” benefit of relational storage. A larger amount of meaningful data can be packed into less space because nothing is repeated. Optimizing storage by eliminating redundancies is called normalization.

90

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Although relational data structure is still considered the industry-preferred model, fully normalized data does have its drawbacks. A fully normalized data structure can suffer terribly in select performance when compared to nonrelational data storage due to its dependencies on join operations. When data is needed from multiple tables, the tables must be joined to access the data. The process of resolving joins can be time-consuming and can adversely affect the performance of the entire database. However, when data is updated, the data modifications are confined to a single point of change. This elimination of data redundancy increases the ability to maintain data integrity.

Implementing a Normalized Design Normalization is the process of removing all redundancy from your data storage. When data is fully normalized, there is no repetition of data across tables with the exception of the key that is used to join the tables. The advantages of data normalization can be enormous in terms of space and cost savings, as well as the increased efficiency with which data can be updated and maintained. In this section, you will look at the rules of normalization, otherwise known as the normal forms. The normal forms, or rules of normalization, define exactly what information can be placed in each table and how this information relates to the fields defined as primary keys. Entire books have been written on the subject of normalization; this section will simply hit the highlights and illustrate the first three normal forms, which are the most critical in preserving the integrity of your data.

Skip It If You Must If you are a professional developer, this discussion of database design and normalization may seem a little simplistic. You may be able to design databases in your sleep. If that is the case, feel free to catch a quick nap while we review these concepts for the professional database administrators in the group who do not develop databases as part of their jobs. When the topic turns to database backup operations in a later chapter, the administrators will get a few minutes to nap while the database developers learn some new tricks.

Before we turn to the rules of normalization, let’s review a few terms that we will be using. Entity A topic or subject that you will describe. For example, an entity can be a customer, an order, or a check. Entities are created in databases by creating tables. Field An attribute of an entity. If the entity is a check, its attributes would include check number, date, amount, payee, etc. Because entities are represented in databases as tables, attributes are the fields of the table. Record An instance of an entity. Assuming again that the entity is a check, every check you write would be an instance of the entity. When these checks are entered into a check register, each line of the register represents an individual check or in other words, an instance of the check entity. Using the check entity as an example, the register is actually a table. It has records (or rows) that represent each check written, and it has fields (or columns) that define the individual attributes of each check.

DESIGNING DATA STORAGE

|

THE FIRST NORMAL FORM The first normal form dictates that every instance of an entity referenced in the table will be unique and that all of the fields in the table will contain data that is nondecomposable. Nondecomposable data is data that cannot be broken down into smaller pieces. The first normal form sounds complicated, but it can be broken down very easily into some component parts. First, every record in the table must be unique. This means that every time you enter information about an instance of an entity, that instance will be unique to the table. The easiest way to identify a record as unique is to declare a primary key on the table. In fact, this is just what the first normal form requires. Primary keys must comply with a number of different conditions. Any data entered into a primary key field anywhere in that table must be unique in that table and no duplications can occur. The primary key must not allow null entries. There must be a primary key entry for every record. Although not required, it is more efficient and, therefore, preferable if the primary key is a small numeric value. The second component of the first normal form is that all data entered in the table must be nondecomposable. Consider, for example, a field in the table called Name in which we enter the first name, middle initial, and last name of every customer. Such a field would be a violation of the first normal form because it could be broken down into smaller pieces. If you have created a field called Name, you can still sort by either first or last name all you have to do is parse the name value for every single record and pull out only the information with which you want to work. Then you can write a custom procedure to sort, search, or otherwise manipulate the data you have extracted. However, this is a high-overhead solution. If you break the field down into pieces, you shouldn’t have to go through as much effort to re-create the field in its entirety. Fortunately for us, SQL Server assumes that you will be working with nondecomposable data as a general rule, and the Transact-SQL language includes the mechanisms that can reassemble data. This nondecomposable data rule applies to records as well as individual fields. Sometimes it is better to break a single record into multiple records to avoid decomposable data at the record level. For example, assume that in your Order table you have a field for order number, order date, customer number, and then a series of fields called product1, product2, product3, and so forth that represent all of the individual products requested in a single order. This structure is actually a violation of the first normal form because the record itself is decomposable. Figure 4.1 shows an example of the structure. Note that the Product table is aliased three times to support each of the three relationships.

Figure 4.1

Product

Violation of the first normal form

Order PK

Order_Num Cust_Num Prod_Num 1 Prod_Num 2 Prod_Num 3 Order_Date

Prod_Num Prod_Name Price

PK

Product Prod_Num Prod_Name Price

PK

Product Prod_Num Prod_Name Price

PK

PK=Primary Key

91

92

| CHAPTER 4

TABLES AND CRUD OPERATIONS

This situation can be rectified in a couple of different ways. One way is to change the primary key on the Order table to a composite key of the two fields that includes the order number and an invoice line number. The composite key will then represent a single line item in the invoice. Although this will solve the initial problem, it could be argued that this violates our entity relationship model because obviously now we are treating an order and the line item within an order as individual entities. Figure 4.2 illustrates this approach.

Figure 4.2

Product

Composite key solution

Prod_Num Prod_Name Price

Order PK

Order_Num Line_Num Cust_Num Prod_Num Quantity Order_Date

PK

PK=Primary Key

The most appropriate solution to this problem would be to create a many-to-many relationship between the Order table and the Product table. Creating this type of relationship requires another table to be created to hold the detail between the Order table and the Product table. In the example in Figure 4.3, it is called the Invoice_line table. This type of table, often called an association table, represents a single line item on an invoice. Note that the primary key on this table is a composite of the invoice number and the product number, a combination that will never be repeated.

Figure 4.3 Many-to-many solution

Order PK

Order_Num Cust_Num Order_Date PK=Primary Key

Invoice_Line PK

Order_Num Prod_Num Quantity

Product Prod_Num Prod_Name Price

PK

THE SECOND NORMAL FORM The second normal form states that every field in the table should relate to the primary key field in its entirety. This is primarily an issue when tables have composite primary keys consisting of multiple fields. If a composite key is present, then every field in that table must relate to all fields comprising that key, not just to one or some. In our previous example, we created a table called Invoice_line that held a many-to-many relationship between the Order table and the Product table. The entity being described by this table is a single line item on invoice. Referring back to Figure 4.3, notice that the Price field is being stored in the Product table and not in the Invoice_line table. If the Invoice_line table defines a single line item in an invoice, why isn’t the Price field held in this table? The answer relates to the second normal form. If the Price field were included in the Invoice_ line table, that would be a violation of the second normal form. This is because the price of the product is really an attribute of the product itself, not an attribute of the entire order or a line item in an order. If the Price field were to be included in the Invoice_line table, then that field would relate only to one of the fields in the composite key, namely the Prod_num field. This is a textbook violation of this rule.

DESIGNING DATA STORAGE

|

That Depends on What You Mean by Price Where a field is defined can often depend on how that data is used and interpreted. For example, in the previous illustration the Price field is included in the Product table because the assumption is that product price is fixed for each product. This assumption may not always be true. What if the price the customer pays for the product depends on something else, such as the number of units ordered? In this case, there may actually be two different prices that you need to store. While the Product table stores the base price for the product, the Invoice_line table may store another price that is inclusive of discounts, customer promotions, and so forth. To avoid ambiguity, you should use a different column name in the Invoice_line table, such as Extended_price or Discounted_price, to indicate that the price paid on this order line item might be different than the base price stored in the Product table. This would not be a violation of the second normal form because the value of Extended_price would be specific to the order line item (not the product itself).

THE THIRD NORMAL FORM The third normal form states that any non-key field in a table must relate to the primary key of the table and not to any other field. The primary key in this case may either be a composite or single field key. This form forces all data found in a table to relate exclusively to the entity that the table describes. Assume that in our previous business model example, customers will only order a single product from the firm. This restriction eliminates the need for a many-to-many relationship and an Invoice_line table. In this scenario, all of the information needed to track an order is found in the Order table. In Figure 4.4, there is a violation of the third normal form. Note that the Price field is included in the Order table. As discussed previously, the price relates to the product, not the order. Although the Prod_num field is found in the table, it acts as a foreign key field in relation to the Product table, not as a primary key field. Because every field in the table must relate to the primary key field and not any other field, the Price field violates the third normal form.

Figure 4.4

Product

Violation of the third normal form

Order PK

Order_Num Cust_Num Prod_Num Quantity Price Order_Date

Prod_Num Prod_Name Vendor_Num Prod_Desc

PK

ADVANTAGES AND DISADVANTAGES OF NORMALIZATION Although some of the advantages and disadvantages of normalization were alluded to earlier in this chapter, they are definitely worth repeating. Normalized data structures can have significant advantages over non-normalized structures as they relate to data entry and data maintenance. Yet these same structures can suffer from some prohibitive performance problems. On the positive side of the normalization picture is that it completely removes data redundancy, therefore optimizing storage space on the data source. With redundancy virtually

93

94

| CHAPTER 4

TABLES AND CRUD OPERATIONS

eliminated, you can use the space to store more data instead of restoring the same data redundantly in more than one place. The maintenance tasks also get much easier when you have a truly normalized design. Because there is no data redundancy, you’ll never have to change a value in more than one place. If your data is extremely volatile, this is an advantage that usually outweighs all possible disadvantages. Although there are a number of good things about normalized data structures, they still have some weaknesses. The primary weakness of normalization lies in its strength: the subdividing of information into single-entity tables. This separation of information requires multiple tables to be related to get all of the information that you need. These joins can be quite costly. SQL Server has a variety of mechanisms that it can use to resolve join operations, but the most common of these is nested looping. Nested looping arranges the joined tables sequentially so that whenever a qualifying record is found in an outside table, an inside table is scanned to find all matching records. For example, assume that you are joining two tables together. Assume further that a total of 25 qualifying records will be extracted from the outside table. This means that for every qualifying record of the outside table, you must scan the inside table once to find all matching and qualifying records. If there are a total of 25 qualifying records in the outside table, there will be a total of 26 accesses to the set of tables: 1 on the outside and 25 on the inside. Although indexes and join orders can make this process much more efficient, it is still a timeconsuming and I/O-intensive process. If joining two tables is troublesome, imagine what will happen when you start joining three and four tables. More tables simply multiply this effect, making it nearly impossible to join large numbers of tables with any reasonable performance.

Denormalization Even if you have taken the time to build a normalized database your old college professor would be proud of, it still may not be perfect. The performance problems caused by a normalized design might be far too substantial for you to accept. In this case, it is time to start considering various approaches to denormalization. Denormalization is the process of deliberately breaking the rules of normalization in the hope that you will gain some performance benefits. There is no magic ticket to denormalization. It is a process of cost-benefit analysis, testing and retesting, and constant reevaluation. Of course, every denormalization will have costs to maintain. These must be considered before a normalized or denormalized design is chosen. You should consider those denormalized designs only when the benefits of denormalization outweigh the cost of maintaining the denormalization.

DUPLICATE ATTRIBUTES There are numerous approaches to denormalization. One approach is to provide redundant attributes and tables. In the previous examples, you determined that placing the Price field in the Order table violated the third normal form. If you follow the rules exactly, you will need to do a join from the Order table to the Product table to access pricing information for the order products. This may be a time-consuming JOIN statement if you are constantly running reports to calculate the total cost of goods sold. You might consider placing the Price field in the Order table as well as the Product table. Although this violates the rules, the benefits are obvious. You no longer have to perform a JOIN statement to access price information for ordered products. The maintenance costs of this approach include updating duplicate attributes when the original attributes are updated. Although this can be handled very easily using procedures that will update all required fields in all tables, it may significantly slow the update process if the attributes are modified on a regular basis. It is best if duplicate attributes are nonvolatile.

DESIGNING DATA STORAGE

|

DUPLICATE KEYS As discussed earlier, every table that you add to the JOIN list multiplies exponentially the number of scans required. The fewer scans required, the less I/O will be needed to satisfy the data request. Providing redundant keys is one way to reduce the number of joins. Take a look at another join scenario. Figure 4.5 illustrates an Employee table that is related to a Customer table. Each customer has one employee assigned to him or her. The Customer table is then related to an Order table that shows the orders made by the customer. To generate a report about the orders sold by an employee, a join would have to be made between all three tables. The costs associated with this approach mirror those incurred with the duplicate-attribute approach. When every key value changes, the value must be updated in all tables. Once again, this approach is best when used with nonvolatile values.

Figure 4.5 Normalized threetable join

Employee

Customer

Emp_Num . . .

Cust_Num Emp_Num . . .

Order Ord_Num Cust_Num . . .

Although it will require breaking some rules, you can reduce the total number of joins required to execute this query. Including the Emp_num field in the Order table will provide a direct relationship between employees and orders. Identifying the orders placed by every employee’s customers will be more efficient because you won’t need to go through the Customer table if customer information is not needed.

TABLE PARTITIONING The entity relationship model and the rules of normalization both specify that only one table per entity should exist inside a database. This is a perfectly reasonable requirement; however, this means that often tables become quite large and they may contain a significant amount of data that is not frequently used. If the data can be broken into multiple tables, a query will have to wade through much less data to find what is actually desired. These tables can be broken apart in two ways: either by row or by column partitioning. If you regularly work with every record in the table, but you tend to use only a few fields of the table, you may consider partitioning the table by column. Using this strategy, you will create two tables, each with a different structure. Although they will both contain the primary key value for each record, the other fields will be placed in the tables based solely on their frequency of access. One table will have the fields that are accessed on a regular basis, and the other table will contain less-frequently accessed fields. Because each of these tables contains the primary key, they can be easily related to reconstruct the entire table if needed. Perhaps you have a very large table full of both current and historical information. When these types of tables are present in a database, the current information is usually accessed quite frequently and the historical data is accessed much less often. This situation may lend itself to breaking down the table by rows. To accomplish this, create two identical tables, each with every field being tracked. The current information will be placed in one table and the historical information will be placed in the other table. Periodically, data will be moved from the current table to the historical table as the data ages. Using a UNION statement to reconstruct the original table, you can easily reassemble the data.

95

96

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Partitioning Made Easy Archiving data into multiple tables based on frequency of use is such a common and useful technique that SQL Server 2008 includes significant enhancements to make this process easier. Rather than requiring you to create multiple tables, SQL Server 2008 allows you to define multiple partitions on a single table and define segmentation logic that helps automate the process of data archival. This will be discussed in greater detail later in this chapter in the section on table partitioning.

As you proceed with your database designs, be sure to consider normalization and denormalization strategies as appropriate. Design your application for performance, but also design for extensibility and maintainability. Remember that a poorly designed data structure can have farreaching consequences. Once bad designs are rolled into production, they can be very difficult to refactor without some pain. Always consider the future needs of your designs and your expected performance metrics before making the final decisions on your database design proposals.

Creating and Dropping SQL Server Tables Now that we have walked through the design concepts, it’s time to take a look at the mechanics of creating tables. You have two options for creating tables. You can either perform the action by using Transact-SQL code, or you can use the graphical user interface provided by the SQL Server Management Studio tool. We will show you both approaches. As you have probably already noticed, most operations in SQL Server can be accomplished in the same two ways, so from this point out, we will show you both methods unless there is a particular task that can only be completed using one approach or the other.

This Is Only a Test If you are going to follow along with any of the examples in this book, it is a good idea to install a separate instance of SQL Server specifically for that purpose. This way the configuration changes you make to the server will not affect any of the other work you are doing or (ouch!) your production servers. Give yourself a playground where you will not be concerned about the impact of your actions on anything else. In this chapter, we will use the database name “SandboxDB,” but you can replace that with any name that reminds you that this is the database you are using for your sandbox.

The Basics of Table Creation The simple form of the CREATE฀TABLE statement is this: CREATE฀TABLE฀ ฀฀[฀database_name฀.฀[฀schema_name฀]฀.฀|฀schema_name฀.฀]฀table_name฀ ฀฀฀฀(฀฀[฀,...n฀]฀)฀ ฀[฀;฀]

This syntax allows the developer to identify the table by name and by schema. Following the name of the table is a list of column definitions placed in parentheses.

CREATING AND DROPPING SQL SERVER TABLES

|

Within each column definition, column constraints can be provided if necessary. Also, table constraints can be defined in the CREATE TABLE statement. Constraints will be addressed in Chapter 6, “Managing Data Integrity,” so we will defer our discussion of that portion of the syntax until that time. The column definition can contain the following: Datatype You must specify a datatype for each table column. These datatypes, discussed in Chapter 2, “Understanding SQL Server Architecture,” define storage requirements for each column in the table. Collation You have the option of defining collations for each individual column that differ from the table collation or the server default collation. Nullability Every column can be explicitly specified as to whether it will allow null values. If not provided, the database option ANSI฀NULL฀default฀is used. Identity This auto-number property allows automatic incrementing of integer values for the indicated column, sometimes used as a contrived key or identifier. As an illustration, suppose that you wanted to create a customer table with the following characteristics: •u฀ An auto-incrementing ID value, entry required •u฀ A customer name with a maximum of 25 characters, entry required •u฀ A customer state code fixed to two characters, entry required •u฀ A customer credit limit that can potentially accept decimals, entry optional

Given this set of characteristics, the SQL statement to create this table would be written as illustrated in Listing 4.1. Note that the formatting in this listing is not required, but we have included it for readability. You should follow your own organization’s standards for code formatting. (If there is no standard, maybe it’s time to create one.)

Listing 4.1

Creating a Customer Table

USE฀SandboxDB; GO CREATE฀TABLE฀dbo.Customer ( ฀฀฀฀฀฀CustomerID฀฀฀฀฀฀฀฀int฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀NOT฀NULL฀฀฀฀IDENTITY(1,1), ฀฀฀฀฀฀CustomerName฀฀฀฀฀฀varchar(25)฀฀฀฀฀฀฀NOT฀NULL, ฀฀฀฀฀฀StateCode฀฀฀฀฀฀฀฀฀char(2)฀฀฀฀฀฀฀฀฀฀฀NOT฀NULL, ฀฀฀฀฀฀CreditLimit฀฀฀฀฀฀฀money฀฀฀฀฀฀฀฀฀฀฀฀฀NULL ); GO

If you want to create the same table using the SQL Server Management Studio:

1. Begin by opening the client and connecting to your server through the Object Explorer. 2. Expand the target database in the Object Explorer and locate the Tables folder.

97

98

| CHAPTER 4

TABLES AND CRUD OPERATIONS

3. Right-click the Tables folder and choose New Table from the menu. This will open a dialog that you see in Figure 4.6.

Figure 4.6 Creating a table with the SQL Server Management Studio

Note that in Figure 4.6, the screen is divided into three pieces. The upper-left portion of the screen defines the columns, the lower-left portion of the screen defines column properties, and the right side of the screen defines table properties. In this dialog, the CustomerID column is selected and some of its column properties are displayed in the lower-left portion of the dialog. You see here that the identity specification is defined in the column properties including the identity seed (the starting point) and the identity increment values. The table properties on the right are not specific to any individual column, but rather to the table as a whole. This is where the table name is specified along with its schema identifier. Note, however, that there is some redundancy. The Identity column is also defined in the table properties. Because there is a rule that says that we can have only one identity column per table, this option is also listed in the table properties.

Computed Columns in Tables One of your options when creating a table is to include computed columns. Although including decomposable data in the table is a violation of the first normal form, it can sometimes be convenient to include this information to avoid performing the calculations when the data is queried. As with any denormalization, there will be trade-offs. In its basic form, the computed column simply stores the formula logic in the table definition so that extracting data from this column will automatically perform the desired calculation. Using this approach, no computed data is actually stored in the table. The primary benefit of this technique is that if you have a calculation that is frequently performed in your queries, you will no longer have to include that calculation in your query logic but instead can select from the computed column, which will perform the calculation for you.

CREATING AND DROPPING SQL SERVER TABLES

There are some limitations to the use of a computed column. It cannot be configured with a default constraint (covered in Chapter 6) or as a foreign key, nor can it be the target of an update operation. If you want to complete the denormalization, you can mark the computed column as persisted. This takes the extra step of storing the value of the calculation into the table. This approach shifts the overhead of performing the calculation from the point in time that the data is selected to when the data is inserted and updated. This approach works best when the calculation is frequently needed, but the fields that make up the calculated value are nonvolatile. This action also requires a calculation to be deterministic in nature but permits the creation of an index on the computed column.

Calculations and Determinism Numerous features of SQL Server, such as indexed views and persisted computed columns, require formulas that are deterministic. A deterministic calculation is one that can be repeated at any point in the future and will always return the same result as long as the inputs do not change. For example, suppose you have a CustomerOrder table with Price and Quantity columns. These columns could be used to create a computed column for the total. As long as the values entered in the price or quantity columns do not change, the total will never change. This calculation is deterministic. However, suppose that you want to calculate the number of days that payment is past due. Assuming that you are storing the due date of the payment in your table, you would perform the calculation by comparing the current date and time with the due date and time. Because the function GetDate() returns a different value with every subsequent execution, any calculation that uses this function, such as our past-due example, would be nondeterministic in nature. Although you could still use this formula in a computed column, it cannot be persisted.

To include a computed column in a table, specify the column formula along with a column name in the column definition list. Optionally, you can also specify that the column should be persisted if you want to use this feature and the calculation is deterministic. Listing 4.2 illustrates the use of a computed column in a CREATE฀TABLE statement for a CustomerOrder table.

Listing 4.2

Using Computed Columns in the Table

USE฀SandboxDB; GO CREATE฀TABLE฀dbo.CustomerOrder ( ฀฀฀฀฀฀OrderID฀฀฀฀฀int฀฀฀฀฀฀฀฀฀NOT฀NULL฀฀฀฀Identity(1,1), ฀฀฀฀฀฀ProductID฀฀฀int฀฀฀฀฀฀฀฀฀NOT฀NULL, ฀฀฀฀฀฀Price฀฀฀฀฀฀฀money฀฀฀฀฀฀฀NOT฀NULL, ฀฀฀฀฀฀Quantity฀฀฀฀int฀฀฀฀฀฀฀฀฀NOT฀NULL, ฀฀฀฀฀฀Total฀as฀Price฀*฀Quantity฀PERSISTED ); GO

|

99

100

| CHAPTER 4

TABLES AND CRUD OPERATIONS

INSERT฀INTO฀dbo.CustomerOrder฀(ProductID,฀Price,฀Quantity) VALUES฀(1,฀10,฀10); SELECT฀*฀FROM฀dbo.CustomerOrder; GO

In this listing, the Total column is expressed as a computation of the price value times the quantity value. Because this calculation is deterministic, it can be persisted. The use of the PERSISTED keyword in the column definition indicates that this value will be stored in the table data pages so that the calculation will not have to be performed with every extraction. Following the CREATE฀TABLE statement, the row is inserted into the table by providing ProductID, Price, and Quantity values. Notice that no values are provided for OrderID or Total. These values are determined automatically by the data engine based on the table specifications.

Dropping Tables Dropping a table from a database is a simple process. Assuming that you are the owner of the table or you have the necessary permissions, you can drop a table by using the DROP฀TABLE statement. Assuming that you wanted to remove the CustomerOrder table from the database, you could use this statement. USE฀SandboxDB; GO DROP฀TABLE฀dbo.CustomerOrder; GO

Be careful! Once you execute this statement, it is committed. The table and its data will be removed from the database and you will have to restore from a backup if you want to recover the data.

Table Partitioning Another common denormalization is table partitioning. In the past, you may have performed table partitioning manually by creating multiple tables and separating data into the appropriate tables. Partitioning using this approach can be very labor intensive. If data will be placed in separate tables at the time that it is inserted into the database, your procedures must be aware of the partitioning and be written to accommodate that logic. This creates a brittle architecture because if your partitioning needs ever change, it might require significant work to modify the application to implement that change. The benefit of this denormalization, however, can be significant. For this reason, Microsoft has included table partitioning in the Transact-SQL syntax, which provides extensive support for custom table partitioning logic. This approach greatly simplifies table partitioning, particularly the process of maintaining and potentially modifying those partitions. This technique requires you to create both a partition function, which will define how the tables will be broken down, and a partition scheme, which will define how the partition function will be implemented. A table can then be created on that scheme. This makes the process of partitioning the table transparent to the procedural developer.

CREATING AND DROPPING SQL SERVER TABLES

|

Notes about Partitioning Although we have not yet discussed the process of creating indexes, the concept of partitioning also applies to indexes. It is also possible to base a table partition and its associated index partitions on the same partition functions, thereby providing consistency in the partition logic. You should consider both tables and indexes when designing a partition plan because this will provide the most reliable and maintainable partition architecture. Also, there are some enhancements to the way that table partitions are processed by the Query Optimizer and data engine that allow thread-per-partition execution on parallel plans. This can significantly speed performance and can reduce competition for “hot” resources. If you evaluated table partitioning in SQL Server 2005 and were unhappy with the performance result, you might want to reevaluate it in SQL Server 2008 if query activity is likely to be spread across multiple partitions. Although this feature is supported only in the Enterprise and Developer editions of SQL Server 2008, it is available in the Evaluation edition if you want to test drive the benefits before committing to an Enterprise Edition license.

CREATING THE PARTITION FUNCTION A partition function is a model that defines how data in a table or index will ultimately be broken down. The partition function consists of three elements: •u฀ A function name •u฀ An input datatype that represents the datatype of the column in the table or index on

which the partition is based •u฀ A set of partition boundaries that represents the breakpoints which will determine into

which partition a data row will be placed The basic syntax looks like this: CREATE฀PARTITION฀FUNCTION฀partition_function_name฀(฀input_parameter_type฀) AS฀RANGE฀[฀LEFT฀|฀RIGHT฀]฀ FOR฀VALUES฀(฀[฀boundary_value฀[฀,...n฀]฀]฀)฀ [฀;฀]

Assume that you have one or more tables that you want to partition by date. In this example, we will assume that anything entered in the current calendar year should be in one partition, anything in the previous calendar year should be in another partition, and anything earlier than the previous calendar year should be in a third partition. Assuming that the current calendar year is 2008, that would mean that the previous calendar year is 2007 and anything prior to 2007 would be in the third partition. Let’s call this function CalendarPartition as defined in the following snippet: USE฀SandboxDB; CREATE฀PARTITION฀FUNCTION฀CalendarPartition฀(DATE) AS฀RANGE฀RIGHT FOR฀VALUES(‘01/01/2007’,฀‘01/01/2008’);

101

102

| CHAPTER 4

TABLES AND CRUD OPERATIONS

In this example, the datatype specified in the function definition is DATE. This means that any table or index that is partitioned using this function must contain a column of type DATE; the partitioning process will be performed using this column. By providing two breakpoints, we are effectively defining three partitions. One partition will include everything before the first breakpoint, another will include the values between the two breakpoints, and the last will include all values after the final breakpoint. Which partition will include the breakpoint values themselves? Notice the second line of the snippet: AS฀RANGE฀RIGHT. This means that the breakpoints will be included in the right partition. In this example, therefore, the first partition would contain any date up to but not including January 1, 2007. Because that date is the breakpoint, it would be included in the partition on the right. Using this same logic, a value of January 1, 2008 would belong in the third partition. Alternatively, we could have said AS฀RANGE฀LEFT, which would have included the endpoints in the first and second partitions, respectively.

CREATING AND IMPLEMENTING THE PARTITION SCHEME Once the table partitions are created, you will have to store them somewhere. Because one of the primary benefits of partitioning a table or index is the distribution of that table or index across multiple physical locations to avoid contention, you will typically split each partition into a separate filegroup. (You can have multiple partitions—or even all partitions—in a single filegroup, however, if that architecture best meets your needs.) The basic syntax looks like this: CREATE฀PARTITION฀SCHEME฀partition_scheme_name AS฀PARTITION฀partition_function_name [฀ALL฀]฀TO฀(฀{฀file_group_name฀|฀[฀PRIMARY฀]฀}฀[฀,...n฀]฀) [฀;฀]

In this syntax, you will notice that the partition scheme is tied to a partition function. Therefore, whenever the scheme is referenced, the function is implied. The filegroup list at the end of the partition scheme indicates where the partitions will be placed. You can’t place partitions directly on files, only filegroups. The code statement below assumes that you have created four filegroups in the database, named FG1 to FG4. Refer to Chapter 3, “Databases, Files, and Resource Management,” if necessary to get more information about filegroups. If you specify more filegroups in the partition scheme than the number of partitions defined in the partition function, you can use the additional filegroups if new partitions are added later. The following code shows a partition scheme using the CalendarPartition function previously defined. USE฀SandboxDB; CREATE฀PARTITION฀SCHEME฀CalendarScheme AS฀PARTITION฀CalendarPartition TO฀(FG1,฀FG2,฀FG3,฀FG4);

Because the partition function only defined three partitions, but the scheme defines four filegroups, SQL Server must decide what to do with the remaining filegroup. Upon executing this code, you would get this message back from SQL Server: Partition฀scheme฀‘CalendarScheme’฀has฀been฀created฀successfully.฀‘FG4’฀is฀marked฀as฀ the฀next฀used฀filegroup฀in฀partition฀scheme฀‘CalendarScheme’.

CREATING AND DROPPING SQL SERVER TABLES

|

SQL Server is telling you that because it did not have to use the filegroup FG4 in the current scheme, it has been reserved and marked as the filegroup that will be used next if needed. Now that you have created the partition scheme, you can use the scheme in a CREATE฀TABLE statement like this: USE฀SandboxDB; CREATE฀TABLE฀PartitionedTable ( ฀฀฀฀฀฀฀Id฀฀฀฀฀฀฀฀฀฀฀฀฀฀int฀฀฀฀NOT฀NULL฀฀฀฀฀฀Identity(1,1), ฀฀฀฀฀฀฀DateValue฀฀฀฀฀date฀฀฀NOT฀NULL, ) ON฀CalendarScheme(DateValue);

When you specify the partition scheme that the table will use, you will also have to specify the Data column in the table that it will use it to perform the partition. In this case, the value entered in the DateValue column will determine the partition location of the data row. When data is inserted into the table, the partition is completely transparent and does not affect the syntax at all. For example, each of the three insert statements below would insert data into a different partition of the table even though the code does not specify where the data will go. The partition function performs this task. USE฀SandboxDB; INSERT฀INTO฀PartitionedTable฀(DateValue)฀VALUES฀(‘December฀15,฀2006’); INSERT฀INTO฀PartitionedTable฀(DateValue)฀VALUES฀(‘December฀15,฀2007’); INSERT฀INTO฀PartitionedTable฀(DateValue)฀VALUES฀(‘December฀15,฀2008’);

To verify the existence of the partitions, you can use this query: USE฀SandboxDB; SELECT฀partition_id,฀partition_number,฀rows฀ FROM฀sys.partitions WHERE฀object_id฀=฀object_id(‘PartitionedTable’);

You can also verify the range breakpoints by using this query: USE฀SandboxDB; SELECT฀f.name,฀r.boundary_id,฀r.value FROM฀sys.partition_functions฀as฀f INNER฀JOIN฀sys.partition_range_values฀as฀r ฀฀฀฀฀฀฀฀ON฀f.function_id฀=฀r.function_id WHERE฀f.name฀=฀‘CalendarPartition’;

After inserting the data into the table, you can also verify the partition location of each data row by using the $partition keyword. Remember that when you queried from sys.partitions you returned the partition_number value and the number of rows in each partition. Compare the results of that query with this one: USE฀SandboxDB; SELECT฀DateValue,฀ ฀฀฀฀฀฀฀฀$Partition.CalendarPartition(DateValue)฀as฀Partition_Number FROM฀PartitionedTable;

103

104

| CHAPTER 4

TABLES AND CRUD OPERATIONS

These results show that the rows have been effectively distributed across filegroups with no additional work on the part of either the developer or the database administrator. A user or procedural developer would never have to know that the table was partitioned.

But What If You Like GUI Partitions? SQL Server 2008 frequently has artifacts that you can view or script from the Management Studio, but that you can’t create directly using the GUI tools. Partition functions and schemes fall into this category. If you look at the Object Explorer in the following graphic, you will see that although you can script and drop partition artifacts from the GUI, you can’t create them here.

MODIFYING PARTITIONS In the typical business, archiving and partitioning needs change over time. In the year 2008, our partitioning scheme may make perfect sense, but what do we do on January 1, 2009? Do we still want to load current data with the calendar year 2008 data? Probably not, but how do we make the change? What we need to do in this situation is add another partition to store the calendar year 2009 data and merge the 2007 data into the first partition. Let’s take a closer look at how we would do this.

SELECTING DATA FROM A TABLE

|

The first thing that we need to do is to modify the partition function to define the partition behavior of a value entered for the calendar year 2009. You can do this by executing an ALTER฀ PARTITION FUNCTION statement like this one: USE฀SandboxDB; ALTER฀PARTITION฀FUNCTION฀CalendarPartition() SPLIT฀RANGE฀(‘01/01/2009’);

If you re-execute the previous query that joined the sys.partition_functions view and the sys.partition_range_values view, you will notice that there is another boundary point in our function. This function now defines four partitions instead of three. The change has also been committed to the artifacts that use the function. Execute the following statements and evaluate the results: USE฀SandboxDB; INSERT฀INTO฀PartitionedTable฀(DateValue)฀Values฀(‘December฀15,฀2009’); SELECT฀DateValue,฀ ฀฀฀฀฀฀฀฀$Partition.CalendarPartition(DateValue)฀as฀Partition_Number FROM฀PartitionedTable;

As you will see from the results, simply adding the new partition to the function provided the information necessary for the new data to be inserted into the new partition. Because the FG4 filegroup was previously marked as the next used filegroup, it automatically becomes the host of the new partition. Note that you can use the ALTER฀PARTITION฀SCHEME statement if you want to change the next used filegroup. This only gets us part of the way there, however. Now we have four partitions. What we really wanted was three partitions, because we wanted to merge the 2007 data into the first partition with the rest of the archived data. To do this, we need to make another alteration to partition function. Use the following code to merge the 2007 data into the archive: USE฀SandboxDB; ALTER฀PARTITION฀FUNCTION฀CalendarPartition() MERGE฀RANGE฀(‘01/01/2007’);

This code removes the boundary for January 1, 2007. This means that the first boundary value is now January 1, 2008, so we are back to three partitions again: one for everything before 2008, one for the year 2008, and one for 2009 and later. If you have been following along with this example and entering this code, re-execute some of the previous queries and take a look at how the partitions are currently organized. You should see a total of three partitions. There will be two rows in partition 1, and one row each on partitions 2 and 3. This simple process can then be repeated as necessary without ever having to modify any portion of the actual application.

Selecting Data from a Table If you have had any previous exposure to SQL Server, the first things you probably learned how to do were logging in to the server and executing a simple SELECT statement. In this book we assume that you are not brand new to SQL Server, so we can safely pass over much of the basic SELECT syntax. In this section, however, we will cover some more advanced query statements with which you may not have been able to spend a lot of time. For those of you who have

105

106

| CHAPTER 4

TABLES AND CRUD OPERATIONS

written a lot of simple queries but have not yet taken the next step, we hope that these next few pages will be help bring it all together. Even if you are already an accomplished developer, you may want to skim through this section to see if there is anything you have missed.

What about the Basics? We assume that most readers of this book have already been exposed to the basic concepts of the SQL query. If that is not the case for you, you might want to do a little background reading before tackling this chapter. There are plenty of resources online that cover the basics of SQL syntax. A search should return numerous resources. You might also want to look at the book SQL for Dummies (John Wiley & Sons Inc., 2006), which has a great overview of basic SQL syntax.

Aggregation and Grouping Shifting our attention back to the AdventureWorks2008 sample database, let’s suppose that you want to return a list of contacts from the Person.Person table in ascending order by last name. You could use the following query: USE฀AdventureWorks2008; SELECT฀FirstName,฀MiddleName,฀LastName FROM฀Person.Person ORDER฀BY฀LastName฀ASC;

What Is a Person.Person? A fully qualified artifact reference in SQL Server uses what is called the four-part naming convention. The four parts of the convention are ServerName.DatabaseName.SchemaName.ObjectName. Therefore, the fully qualified name of the table that we are selecting from in this example is .AdventureWorks2008.Person.Person. Because you are executing the query on the server you are connected to, you do not have to restate the server name. It is understood. The same is true with the database name. Because you already issued a USE statement to change the database context to AdventureWorks2008, there is no need to include the database name in the query. However, best practice in most cases is to include the last two parts of the name in every query. There is a schema in the database called Person. The best way to think of the schema is as a namespace for other artifacts. It is a way of grouping artifacts, such as tables and stored procedures, that have special relationships. Person.Person represents a Person table in the Person schema. We will talk more about schemas later when we deal with user security. For now, just note that every artifact is in a schema and that we should include that schema name in every query.

This query will give us the list of people sorted in the way that we like. But what if you need to know the total number of people who have the same last name? For example, how many

SELECTING DATA FROM A TABLE

|

Johnsons do we have? How many Robinsons are there? You could take the list that you just generated and manually count the entries for each last name, but that would be a very time-consuming task. For example, if you look at the results of the query that you just executed, you will notice that it returned almost 20,000 rows, far too many to start counting by hand. Fortunately, SQL supports numerous aggregate functions that, when used in conjunction with the GROUP฀BY clause, can give you the breakdown you are seeking. You can use these aggregates to do everything from simple counts to more advanced calculations such as summations, averages, or even statistical standard deviations. Table 4.1 provides a list of standard aggregate functions in SQL Server 2008, along with a description of each.

Table 4.1

Aggregate Functions in SQL Server 2008

Function

Description

AVG

Returns the average value in the set. Ignores null values; can be configured to average all values (the default) or only distinct values in the set.

CHECKSUM_AGG

Returns the checksum of the values in the group, either all or distinct, ignoring null values.

COUNT

Returns the number of rows, all or distinct, based on an expression or (optionally) a simple row count.

COUNT_BIG

Executes like COUNT, except that it returns a bigint rather than an int datatype.

GROUPING

Indicates if a specified column in a GROUP฀BY list is aggregate. Returns 0 or 1.

MAX

Returns the maximum value in the set based on the provided column name.

MIN

Returns the minimum value in the set based on the provided column name.

SUM

Returns the sum of values in the set based on the provided column name.

STDEV

Returns the statistical standard deviation of all values based on the provided column name.

STDEVP

Returns the statistical population standard deviation of all values based on the provided column name.

VAR

Returns the statistical variance of all values based on the provided column name.

VARP

Returns the statistical population variance of all values based on the provided column name.

In this case, we are interested in a COUNT aggregate. Because the value returned for each breakpoint will not be larger than an int (a 4-byte integer), we will use the COUNT function rather than the COUNT_BIG function, which would return an 8-byte integer value.

107

108

| CHAPTER 4

TABLES AND CRUD OPERATIONS

The resulting query would look like this: USE฀AdventureWorks2008; SELECT฀LastName,฀COUNT(LastName)฀as฀CountOfNames FROM฀Person.Person GROUP฀BY฀LastName ORDER฀BY฀LastName฀ASC;

This query produces a new column called CountOfNames that contains the total number of entries in the table for any specific last name. Notice how the query is grouped by last name. This is very important because the syntax rule requires that any SELECT list that contains both aggregated and nonaggregated data must be grouped by the nonaggregated content. Notice how the GROUP฀BY clause provides breakpoints for the aggregate. If you want to find out how many people have exactly the same first name and last name, you need to use a query like this one: USE฀AdventureWorks2008; SELECT฀FirstName,LastName,฀COUNT(LastName)฀as฀CountOfNames FROM฀Person.Person GROUP฀BY฀FirstName,฀LastName ORDER฀BY฀LastName฀ASC;

Because the SELECT list now contains both first name and last name, both first name and last name must also be in the GROUP฀BY clause. Notice that the COUNT function uses only LastName as a parameter. This function, which can only take a single column name as a parameter, uses this column to know what values to count. Try executing the same query again, but modify the COUNT function so that it reads COUNT(MiddleName)฀as฀CountOfNames. Notice what this does to your counts. Because the MiddleName column frequently contains nulls, which are not counted by the aggregate, there are numerous first name–last name combinations that return a count value of 0. You are now answering a new question: How many people in each first name–last name combination have a middle name provided? Here is another example. Assume you wanted a count of all rows, including those that may contain some null values. To get this, you would use COUNT(*)฀as฀CountOfNames. This counts rows instead of counting non-null entries in a particular column. Also, You could also use a WHERE clause to filter out null values before aggregating, in which case you would not have to use the column name. As you can see from these examples, you have to decide what the real question is before you can formulate a query that will provide the correct answer. Consider the following three queries: USE฀AdventureWorks2008; SELECT฀COUNT(*)฀FROM฀Person.Person; SELECT฀COUNT(MiddleName)฀FROM฀Person.Person; SELECT฀COUNT(*)฀FROM฀Person.Person฀Where฀MiddleName฀IS฀NOT฀NULL;

SELECTING DATA FROM A TABLE

|

The first query will return a count of all rows in the table. The second and third queries will give you exactly the same information: the number of people who have a middle name provided in the database. Frequently, multiple queries will return the same value. When this is the case, you should try to use the query format that will give you the best performance or (depending on circumstances) the one that is the easiest to maintain and modify later.

Special Aggregate Conditions Be aware that COUNT and COUNT_BIG are the only aggregates that give you an option to include all rows by using the asterisk (*) as a parameter. This really does not make sense for other aggregates. For example, look at the MAX aggregate. This function provides the maximum value in the column provided as a parameter. This function would make no sense in the MAX(*)format because there would be no indication of which column to use to locate a maximum value. An aggregate that returns only a single value (a scalar aggregate) can also be used anywhere a value expression can be used, such as in a WHERE clause. Be careful when using a scalar aggregate, because doing so can have some negative performance impacts.

Another useful technique when executing aggregates is to use a HAVING clause. Unlike a WHERE clause in a query, which filters out individual rows before the result set is created, a HAVING clause filters out groups that do not meet specific conditions. For example, assume you want to get a result that provides a count of all “persons” with a last name beginning with the letter “A” that have the same last name. Assume further that you only want the query to return the groups that have at least 10 last names. Your query will actually perform two different operations. The first operation filters out the data to create the groups. Only people with a last name starting with the letter “A” will be counted. The second operation eliminates any group that does not produce a count of at least 10 “persons.” Look at the following query as an example: USE฀AdventureWorks2008; SELECT฀LastName,฀COUNT(LastName)฀as฀CountOfNames FROM฀Person.Person WHERE฀LastName฀LIKE฀‘A%’ GROUP฀BY฀LastName HAVING฀COUNT(LastName)฀>=฀10;

One somewhat frustrating feature of this type of query is that you can’t use the column alias as an identifier in the having clause. Notice that we had to use the syntax HAVING฀ COUNT(LastName)฀>=฀10 and not HAVING฀COUNT(CountOfNames)฀>=฀10. Be aware of this quirk so you don’t drive yourself nuts trying to figure out what’s wrong with your query.

Joins and Table Correlation In a relational data model, you will often have to join tables to extract relevant information. The type of JOIN statement you use, the join fields that you choose, and the order of the tables that you provide in your JOIN statement can all have an impact on both the data that the query will return

109

110

| CHAPTER 4

TABLES AND CRUD OPERATIONS

and the performance of the query. In fact, the I/O cost resulting from join operations in queries is frequently the most resource-consuming and performance-affecting part of the query process. Let’s begin by considering a simple join operation. Suppose that you wanted to get a list of all of the people in your database who have a phone number in the 702 area code. You are planning a trip to Las Vegas and you want a place to stay. The problem is that the names of the people are in the Person.Person table, but their phone numbers are in the Person.PersonPhone table. This design complies with the first normal form. Because it is possible that one person could have multiple phone numbers, such as home phone, mobile phone, business phone, etc., these numbers had to go into a separate table. There is a common column between the two tables, though. That column is BusinessEntityID. To correlate the date between the two tables, we will have to write a JOIN statement that will link the tables on this field. Consider the following query: USE฀AdventureWorks2008; SELECT฀p.FirstName,฀p.LastName,฀pp.PhoneNumber FROM฀Person.Person฀as฀p INNER฀JOIN฀Person.PersonPhone฀as฀pp ฀฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀pp.BusinessEntityID WHERE฀pp.PhoneNumber฀LIKE฀‘702%’;

In this example, you will see that there are two tables listed in the FROM clause, but these two tables are correlated through a JOIN statement. A JOIN statement generally contains two pieces of information: which tables you are joining and which columns in each of the tables that you will use for the join. You have a variety of options for the JOIN operator that you choose. Although inner joins are the most common, they are by no means the only option. The five join options in SQL Server 2008 are listed in Table 4.2. Note that the alias value listed in the table can be substituted for the formal JOIN operator if you like.

Table 4.2

SQL Server 2008 Join Types

Join Type

Alias

Description

INNER฀JOIN

JOIN

Returns requested data for every row in each table only where there is an exact match on the join field.

LEFT฀OUTER฀JOIN

LEFT฀JOIN

Returns requested data for all rows from the first table stated in the join operation; only returns data for rows from the second stated table where there is a matching value. This can result in null values in the result when the first stated table in the join has a row with no matching row(s) in the second stated table.

RIGHT฀OUTER฀JOIN

RIGHT฀JOIN

Returns requested data for all rows from the second table stated in the join operation; only returns data for rows from the first stated table where there is a matching value. This can result in null values in the result when the second stated table in the join has a row with no matching row(s) in the first stated table.

FULL฀OUTER฀JOIN

FULL฀JOIN

Returns requested data for all rows in both correlated tabled, but the result will contain null values for rows with no matching join value on the other side.

SELECTING DATA FROM A TABLE

Table 4.2

SQL Server 2008 Join Types

|

(continued)

Join Type

Alias

Description

CROSS฀JOIN

N/A

Returns a Cartesian (Cross) product; in other words, all possible combinations of rows between the two tables.

In our previous query example, what would happen if someone listed in the Person.Person table did not have a phone number provided in the Person.PersonPhone table? Because the query is written using the INNER฀JOIN operator, it would return only people with at least one matching record in the PersonPhone table. What if you were to write the query like this? USE฀AdventureWorks2008; SELECT฀p.FirstName,฀p.LastName,฀pp.PhoneNumber FROM฀Person.Person฀as฀p LEFT฀OUTER฀JOIN฀Person.PersonPhone฀as฀pp ฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀pp.BusinessEntityID WHERE฀pp.PhoneNumber฀LIKE฀‘702%’;

In this case, the JOIN operator is LEFT฀OUTER฀JOIN, meaning that all rows will be returned from the Person table, but only matching rows will be returned from the PersonPhone table. This means that some “persons” may be without a registered phone number. A null value will appear in the PhoneNumber column for these rows, because the value is unknown for that person. Note that in the AdventureWorks 2008 database, every person in the Person.Person table has a corresponding entry on the Person.PersonPhone table, so in this case, will all Person rows having matching rows in PersonPhone, the results of the two queries will be the same. Now suppose that you want to join three tables instead of two. For example, this query will give you the name and phone number, but you also need to know if it is a home phone, mobile phone, etc. As you look at the PersonPhone table, you will see that there is no text field that gives you this information, but there is a column named PhoneNumberTypeID. This column relates to the Person.PhoneNumberType table, which contains the data that you need. To get this information, you will have to join the previous query results to the third table, as illustrated in this query: USE฀AdventureWorks2008; SELECT฀p.FirstName,฀p.LastName,฀pp.PhoneNumber,฀pnt.Name FROM฀Person.Person฀as฀p INNER฀JOIN฀Person.PersonPhone฀as฀pp ฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀pp.BusinessEntityID INNER฀JOIN฀Person.PhoneNumberType฀as฀pnt ฀฀฀฀฀฀฀ON฀pp.PhoneNumberTypeID฀=฀pnt.PhoneNumberTypeID WHERE฀pp.PhoneNumber฀LIKE฀‘702%’;

As you can see from these examples, basic JOIN syntax is not difficult to use, but it does require a good understanding of the structure of your database. You have to know where all of the data is and which fields you should use to correlate all of the data. Spending time with your data schemas and learning how the data is distributed will pay off in the long run, because it gives you the tools to give your data consumers exactly what they need to answer their questions.

111

112

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Prepping for the Upgrade If you have previously converted applications from SQL Server 2000 to SQL Server 2005, you have probably already removed the non-ANSI JOIN syntax from your code. The mainstream support for the old syntax was removed in SQL Server 2005, requiring you to run in SQL 2000 compatibility mode if you still wanted to use it. If this does not ring a bell for you, consider the following case. As consultants, we frequently work with companies that are migrating applications from one version of SQL Server to another. Updating obsolete syntax in scripts and stored procedures is particularly problematic in a conversion. One of the syntactical statements that tends to be very problematic is the JOIN syntax. Prior to SQL Server 6.5, the JOIN syntax was part of the WHERE clause. A typical join query looked something like this: SELECT฀a.au_lname,฀ta.royaltyper FROM฀authors฀as฀a,฀titleauthor฀as฀ta WHERE฀a.au_id฀=฀ta.au_id

Notice that the WHERE clause, which should contain filter criteria, contains a join correlation. Left joins were performed by using an *= in the WHERE clause and right joins used an =* operator. Version 6.5 of SQL Server introduced the ANSI JOIN syntax that we now use. Any code written in SQL Server 6.0 or earlier should have been upgraded when the move was made to SQL Server 6.5. One client decided not to modify the code on an upgrade because they were concerned that there was too much code to modify and it would increase the cost of the upgrade. While that was true, all the client did was delay the inevitable. With the release of SQL Server 2005, Microsoft no longer supported the non-ANSI syntax unless the database compatibility option is set to SQL 2000 or earlier. This client is now in a bit of a jam, because the only way to leverage the new language features of SQL Server 2005 is to upgrade their code to ANSI JOIN statements. As of this writing, they are still using the old syntax and running SQL Server 2005 in 2000 compatibility mode. As of the release of SQL Server 2008, the non-ANSI JOIN syntax is on the deprecated list, meaning that in the next release it will not be supported at all because the 2000 compatibility mode will be going away. So the client now has to make the changes if they want to make the upgrade—and they only have the limited time window provided by SQL Server 2008 in which to do the modifications. Meanwhile, because they did not want to support code that used multiple syntax approaches, they have almost doubled the amount of code that will have to be modified to make the change. The moral of this story is that if you know that something has to be changed, do it while you can. Waiting too long to transition your code causes two serious problems. First, you will probably increase your total costs for the transition, because the longer you wait, the more disconnected your developers will probably be from the original code. Second, you will not get the full benefits of the upgrades that you do perform if you do not using the syntax, configurations, and other features that the new options present. If you are going to spend the money on an upgrade, you might as well get the most benefit for your money that you can.

SELECTING DATA FROM A TABLE

|

Subqueries, Derived, and Temporary Tables Subqueries and derived tables are nothing more than nested SELECT statements. These tools are used to dynamically pull data from the tables so that data can be used to resolve another query. By allowing the query logic to get all of its data from the database (having data-driven logic) instead of hard-coding values (which gives you brittle fixed logic), you increase your ability to maintain the code. Subqueries can be scalar or can return a list of values. When a subquery returns both columns and rows, it is often referred to as a derived table. This can be a useful way to avoid using temporary tables.

SCALAR SUBQUERIES When a subquery returns exactly one row and one column of data, it is considered a scalar subquery. A scalar subquery is typically constructed either as a query that selects a single column based on a unique key or as an aggregate value with no grouping. In either case, the result of the query is used in place of the value in the containing query. Consider the following query. USE฀AdventureWorks2008; SELECT฀SalesOrderID,฀OrderQty,฀UnitPrice FROM฀Sales.SalesOrderDetail WHERE฀UnitPrice฀>฀( ฀฀฀฀฀฀฀SELECT฀AVG(UnitPrice) ฀฀฀฀฀฀฀FROM฀Sales.SalesOrderDetail ฀฀฀฀฀฀฀) AND฀OrderQty฀>฀( ฀฀฀฀฀฀฀฀SELECT฀AVG(OrderQty) ฀฀฀฀฀฀฀฀FROM฀Sales.SalesOrderDetail฀ );

This query will return a list of sales orders that meet the conditions of having a higher than average unit price and higher than average order quantity. In other words, it returns your highest value orders. The great thing about a query like this is that even if the data changes, this query will always return accurate results. By comparison, if you calculate the average unit price and average order quantity by hand and hard-code those values into this query, the results will be correct right now, but as soon as the data is modified, adding new orders or changing existing orders, the result set will no longer be accurate.

Structuring a Subquery There are a few rules to remember about subqueries. First, if the subquery is preceded by a comparison operator such as =, , etc., then the subquery must be scalar. It can only return one value. Second, you will also notice from the syntax that every subquery is contained in a set of parentheses. You don’t have to use the same format as in the previous example—because white space is ignored by the parser, you can put parentheses where you want them—but you must put them around every subquery.

113

114

| CHAPTER 4

TABLES AND CRUD OPERATIONS

SUBQUERIES THAT RETURN LISTS When a subquery returns a list of values, it can be used after an IN operator in a query. For example, the following query returns a list of sales territory IDs that are in the North American region. USE฀AdventureWorks2008; SELECT฀TerritoryID FROM฀Sales.SalesTerritory WHERE฀[Group]฀=฀‘North฀America’;

What’s All That Bracket Out There? Just in case you have not seen this syntax option in SQL Server before, take a moment to look at the WHERE clause and notice that the column name Group is enclosed in square brackets. Because the word Group is a SQL Server 2008 reserved word, it requires special treatment. You can use reserved words like this as identifiers in SQL Server, but you must mark them as identifiers so that the SQL Server parser does not treat them as keywords. If you have the option “Quoted Identifiers” turned on, you can use double quotes to mark identifiers, but the standard syntax is to enclose keywords in brackets. The best practice is to avoid using keywords as identifiers altogether.

Because this query returns more than one value, it can’t be used as a scalar subquery would. Instead, this query provides a set of possible values that the outer query can use as a filter. Think of it as an advanced “OR” logic. What if you want to return a list of customer IDs and account numbers for each of your customers in North America? One way to write this query would be like this: USE฀AdventureWorks2008; SELECT฀CustomerID,฀AccountNumber FROM฀Sales.Customer WHERE฀TerritoryID฀IN฀( ฀฀฀฀฀฀฀฀SELECT฀TerritoryID ฀฀฀฀฀฀฀฀FROM฀Sales.SalesTerritory ฀฀฀฀฀฀฀฀WHERE฀[Group]฀=฀‘North฀America’ );

In this example, we just took the query that returned the TerritoryID and used it as a subquery to provide that information to the outer query and act as a filter. It is worth mentioning that a subquery of this nature implies distinctiveness. In other words, there is no need to use the DISTINCT keyword in the subquery. It is implied. Of course, this is not the only way to write this query. We can often rewrite subqueries as join operations and get the same results. For example, the next query will give you exactly the same results as the previous one. Your decision to use one or the other will depend on your performance metrics and maintenance requirements.

SELECTING DATA FROM A TABLE

|

USE฀AdventureWorks2008; SELECT฀c.CustomerID,฀c.AccountNumber FROM฀Sales.Customer฀as฀c INNER฀JOIN฀Sales.SalesTerritory฀as฀st ฀฀฀฀฀฀฀฀ON฀c.TerritoryID฀=฀st.TerritoryID WHERE฀st.[Group]฀=฀‘North฀America’;

DERIVED TABLES You may want to create a temporary table structure, such as a work table, to process intermediate results in your procedure. There are a number of ways to do this. You can use temp tables, table variables, or derived tables. Each method has its own pros and cons. Listing 4.3 illustrates the use of a table variable to temporarily store data.

Listing 4.3

Using Table Variables

USE฀AdventureWorks2008; DECLARE฀@NameAndRole฀table ( ContactName฀฀฀฀฀฀฀nvarchar(101), BusinessRole฀฀฀฀฀฀nvarchar(50), ModifiedDate฀฀฀฀฀฀datetime ); INSERT฀INTO฀@NameAndRole SELECT฀Name,฀‘Vendor’,฀ModifiedDate FROM฀Purchasing.Vendor; INSERT฀INTO฀@NameAndRole SELECT฀p.FirstName฀+฀‘฀‘฀+฀p.LastName,e.JobTitle฀,฀p.ModifiedDate FROM฀Person.Person฀as฀p INNER฀JOIN฀HumanResources.Employee฀as฀e ฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀e.BusinessEntityID; ฀฀฀฀฀฀ SELECT฀ContactName,฀BusinessRole FROM฀@NameAndRole WHERE฀ModifiedDate฀>฀‘20010101’; GO

In Listing 4.3, you can see how data that is very different in structure can be merged to provide a temporary set of values, which is further processed by filtering the set by ModifiedDate. In this case, we are using a table variable, but there is an alternative. You could use a temporary table to do the same thing. Look at Listing 4.4, which achieves the same result using a temporary table.

115

116

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Listing 4.4

Using Temporary Tables

USE฀AdventureWorks2008; CREATE฀TABLE฀#NameAndRole ( ContactName฀฀฀฀฀฀฀nvarchar(101), BusinessRole฀฀฀฀฀฀nvarchar(50), ModifiedDate฀฀฀฀฀฀datetime ); INSERT฀INTO฀#NameAndRole SELECT฀Name,฀‘Vendor’,฀ModifiedDate FROM฀Purchasing.Vendor; INSERT฀INTO฀#NameAndRole SELECT฀p.FirstName฀+฀‘฀‘฀+฀p.LastName,e.JobTitle฀,฀p.ModifiedDate FROM฀Person.Person฀as฀p INNER฀JOIN฀HumanResources.Employee฀as฀e ฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀e.BusinessEntityID; ฀฀฀฀฀฀ SELECT฀ContactName,฀BusinessRole FROM฀#NameAndRole WHERE฀ModifiedDate฀>฀‘20010101’; GO

The primary difference between these two listings is the duration of the temporary structure. Because declared variables are removed from memory after the batch that defines them is complete, the table variables are out of scope as soon as the GO statement executes. Temporary tables on the other hand will remain in scope until the connection that creates them is closed. There are also some performance differences, although it is difficult to say which is better. Depending on the situation as well as the version and service pack of SQL Server that is installed, the performance metrics of table variables versus temporary tables can change! Unless the performance metrics change significantly using one or the other, your best option is to pick the one that makes the most sense in the current situation and stick with it. Another alternative is to use a derived table. In the case of a derived table, the scope is limited to the query itself. It is not available anywhere else in the batch or within the current connection scope. Due to this limited scope, derived tables are often the best way to resolve this type of query when the limited scope is acceptable. Listing 4.5 provides the same results as Listings 4.3 and 4.4 using a derived table.

SELECTING DATA FROM A TABLE

Listing 4.5

|

Using Derived Table Subqueries

USE฀AdventureWorks2008; SELECT฀ContactName,฀BusinessRole FROM฀( ฀฀฀฀฀฀SELECT฀Name฀as฀ContactName,’Vendor’฀as฀BusinessRole,฀ModifiedDate ฀฀฀฀฀฀FROM฀Purchasing.Vendor ฀฀฀฀฀฀ ฀฀฀฀฀฀UNION฀ALL ฀฀฀฀฀฀ ฀฀฀฀฀฀SELECT฀p.FirstName฀+฀‘฀‘฀+฀p.LastName,e.JobTitle,p.ModifiedDate ฀฀฀฀฀฀FROM฀Person.Person฀as฀p ฀฀฀฀฀฀INNER฀JOIN฀HumanResources.Employee฀as฀e ฀฀฀฀฀฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀e.BusinessEntityID ฀฀฀฀฀฀)฀as฀ContactList ฀฀฀฀฀฀ WHERE฀ModifiedDate฀>฀‘20010101’; GO

The example in Listing 4.5 is fairly simple, but a derived table can be used in much more complex scenarios. Derived tables can be used in aggregates, joins, and even as outer queries for additional subqueries or derived tables. Remember, though, that once the query has finished executing, the derived table is out of scope and can no longer be accessed.

CORRELATED SUBQUERIES Sometimes, a subquery cannot process without information from the outer query. In these cases, table aliases are used to define the scope of the query arguments and allow the subquery to be “parameterized” from the outer query. The inner query is, therefore, correlated to the outer query. The net effect is a “back and forth” execution where a single row from the result of the outer query is permitted to pass parameters to the inner query for execution. The following query shows an example of a correlated subquery. USE฀AdventureWorks2008; SELECT฀ p.FirstName฀+฀‘฀‘฀+฀p.LastName฀as฀FullName,฀ ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀e.JobTitle, ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀(SELECT฀Name ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀FROM฀HumanResources.Department฀as฀d ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀WHERE฀d.DepartmentID฀=฀edh.DepartmentID)฀as฀DepartmentName FROM฀Person.Person฀as฀p INNER฀JOIN฀HumanResources.Employee฀as฀e ฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀e.BusinessEntityID INNER฀JOIN฀HumanResources.EmployeeDepartmentHistory฀as฀edh ฀฀฀฀฀฀฀ON฀e.BusinessEntityID฀=฀edh.BusinessEntityID WHERE฀edh.EndDate฀IS฀NULL; GO

117

118

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Because of the way the database is normalized, returning a list of employees with their job titles and current department names is not an easy task. The name information is stored in the Person.Person table, while the job title is in the HumanResources.Employee table. This is a simple join. However getting the current department name is a little trickier. The HumanResources. Department table has the name of the department along with a DepartmentID key. However, the HumanResources.Employee table does not contain the DepartmentID foreign key. This is because it is possible that a single employee has worked in many departments in their career. To maintain this historical data, an EmployeeDepartmentHistory table is created. This table contains one row for every department assignment that an employee has had, along with the DepartmentID and the start and end dates of service with that department. If the entry in the EmployeeDepartmentHistory table has a NULL value for end date, that means that the row represents the employees current department assignment. After filtering out for only NULL values in the end date column, we can turn out attention to getting the department name. You will that the SELECT list contains a subquery, but this subquery uses edh.DepartmentID in its WHERE clause. This value is not defined in the subquery; it comes from the WHERE clause in the outer query. The result is that the subquery is correlated to the outer query. For each row produced by the outer query, the edh.DepartmentID value for that row is passed to the inner query and executed to return the appropriate department name for the SELECT list. This is repeated for every row produced by the outer query. Because the outer query in this example produced 290 rows, the inner query must be executed 290 times to return the appropriate data.

The Optimizer Is Sometimes Smarter than We Are If executing the inner query 290 times to get the department names seems like a lot of work, you are right. Even with only 16 departments in our database, we would be executing the same query over and over again to get the same data. That is very inefficient. Luckily, the query optimizer is not stupid. It would look at this query, decide to create a temporary hash key list, and actually resolve this query with a hash join operation to the Department table, rather than running 290 executions of the same query. This process—whereby the optimizer rewrites the query to find a better way to solve the problem—is sometimes called flattening. When this happens, take it as a hint: If you were paying attention, you probably could have written this query as a join rather than using a subquery. Perhaps that would have been a better option, given that the optimizer chose to use that approach anyway. If you are an accomplished SQL developer, you probably looked at that query and said, “What a moron, he should have just used a join!” Guess what? You are both right and wrong. For performance, it would have been better to use a join, but if we had, then we couldn’t have had this wonderful conversation about query flattening, could we?

Common Table Expressions The Common Table Expression (CTE) was introduced in SQL Server 2005. The purpose of the CTE is to provide a syntactical option that allows the developer to work with temporary data

SELECTING DATA FROM A TABLE

structures logically rather than physically. Instead of having to create temporary tables or table variables to accomplish more complex tasks, the SQL developer can now use the CTE and simplify the logic significantly. The basic format of the CTE is WITH฀expression_name฀[฀(฀column_name฀[,...n]฀)฀]฀ AS฀ (฀CTE_query_definition฀)฀ SELECT฀฀ FROM฀expression_name;฀

The CTE structure is divided into two parts. The first part defines the expression using an expression name and the SQL code that makes up the expression. If you have had previous experience with SQL Server, you might recognize this first section as having the same basic format as a view. The difference is that a view is a procedural object that, when created, physically stores the view metadata in the database so that it can be called again. By contrast, a CTE does not store the definition; it is only valid for that execution. (You might want to think of it as a temporary view.) The second part of the CTE structure is the execution of the CTE, which will generally be a SELECT statement. This must occur immediately after the CTE definition and can’t be separated from it by a GO statement. Rewriting the previous example that we used for temporary and derived tables would give us a result that looks like Listing 4.6. Note that the results would be the same as those for the previous listings.

Listing 4.6

Using Common Table Expressions Instead of Temporary or Derived Tables

USE฀AdventureWorks2008; WITH฀Contact_CTE฀(ContactName,฀BusinessRole,฀ModifiedDate) AS ( ฀฀฀฀฀฀SELECT฀Name,’Vendor’,฀ModifiedDate ฀฀฀฀฀฀FROM฀Purchasing.Vendor ฀฀฀฀฀฀ ฀฀฀฀฀฀UNION฀ALL ฀฀฀฀฀฀ ฀฀฀฀฀฀SELECT฀p.FirstName฀+฀‘฀‘฀+฀p.LastName,e.JobTitle,p.ModifiedDate ฀฀฀฀฀฀FROM฀Person.Person฀as฀p ฀฀฀฀฀฀INNER฀JOIN฀HumanResources.Employee฀as฀e ฀฀฀฀฀฀฀฀฀฀฀฀ON฀p.BusinessEntityID฀=฀e.BusinessEntityID ) SELECT฀ContactName,฀BusinessRole FROM฀Contact_CTE WHERE฀ModifiedDate฀>฀‘20010101’;฀ GO

|

119

120

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Because the CTE is considered a table within the scope of the SELECT statement that follows, you can do anything with this CTE that you can do with any other table, including join operations and aggregating and grouping. The purpose of using this syntax rather than derived tables is to provide cleaner code. It lets the developer define a derived structure in advance so that the SELECT statement that follows does not have to be cluttered with the structure of the derived table, which can be very difficult to read and maintain. Another advantage of using the CTE is that it supports recursive queries. Recursion is one of those operations that has always been challenging in the SQL language. If often requires the use of temporary tables and is usually difficult to read and maintain. The CTE can significantly simplify this logic. This is the basic structure of a recursive query using a CTE. WITH฀cte_name฀(฀column_name฀[,...n]฀)฀ AS฀ (฀ CTE_query_definition฀–-฀Anchor฀member฀is฀defined.฀ UNION฀ALL฀ CTE_query_definition฀–-฀Recursive฀member฀is฀defined฀referencing฀cte_name.฀ )฀ --฀Statement฀using฀the฀CTE฀ SELECT฀*฀ FROM฀cte_name฀

In this syntax, the CTE definition starts with what is called the anchor member. This represents the top-level query of the recursion (the query before any recursion is performed). After the union, the second part, also called the recursive member, references the expression name to specify how the upper-level values will be passed to the recursive layers. You can select from the CTE, and it will perform any necessary recursion for you. Listing 4.7 illustrates the use of a CTE for recursion. Because you may not have the AdventureWorks database handy for testing, a partial result set is provided in Figure 4.7.

Sorry, Not My Data Please note that this code uses data in the AdventureWorks database, also available from Codeplex, rather than the AdventureWorks2008 database that we have been using. This is because the AdventureWorks database contains data that lends itself to this illustration. If you want to execute this example, you will have to install the appropriate database.

Listing 4.7

Using Common Table Expressions for Recursive Operations

USE฀AdventureWorks; WITH฀DirectReports฀(ManagerID,฀EmployeeID,฀EmployeeName,฀Title) AS ( --฀Anchor฀member฀definition ฀฀SELECT฀e.ManagerID,฀e.EmployeeID,฀c.FirstName฀+฀‘฀‘฀+฀c.LastName,฀e.Title

SELECTING DATA FROM A TABLE

฀฀FROM฀HumanResources.Employee฀AS฀e ฀฀INNER฀JOIN฀Person.Contact฀as฀c ฀฀฀฀฀฀฀฀฀฀฀฀ON฀e.ContactID฀=฀c.ContactID ฀฀WHERE฀ManagerID฀IS฀NULL ฀฀UNION฀ALL --฀Recursive฀member฀definition ฀฀SELECT฀e.ManagerID,฀e.EmployeeID,c.FirstName฀+฀‘฀‘฀+฀c.LastName฀,e.Title ฀฀FROM฀HumanResources.Employee฀AS฀e ฀฀INNER฀JOIN฀DirectReports฀AS฀d ฀฀฀฀ON฀e.ManagerID฀=฀d.EmployeeID ฀฀INNER฀JOIN฀Person.Contact฀as฀c ฀฀฀฀฀฀฀฀฀฀฀฀ON฀e.ContactID฀=฀c.ContactID ) --฀Statement฀that฀executes฀the฀CTE SELECT฀EmployeeID,฀EmployeeName,฀Title,฀ManagerID FROM฀DirectReports GO

Figure 4.7 Recursive query results

In the results of the query, you will see that employee number 109 is the chief executive officer. He has no manager, so his ManagerID value is null. The anchor member of the CTE specifically identifies the employee with no manager number. The entire organization will flow down from this record. You will also see in the recursive member how the recursive portion of the query joins to the CTE by correlating the ManagerID field of the recursive member to the EmployeeID field of the parent member in the recursion. Although this syntax can look a little intimidating at first, once you write a couple of these you will see how much easier it is to execute recursion using a CTE than through more traditional means.

|

121

122

| CHAPTER 4

TABLES AND CRUD OPERATIONS

Modifying Data SQL Server 2008 supports four primary data modification keywords: INSERT, UPDATE, DELETE, and MERGE. These Transact-SQL operations are extremely flexible and will provide the tools necessary for the vast majority of data modifications your applications may require. As their names imply, each modification statement is targeted to a specific modification activity. Let’s look at each of them in turn and see how to apply them.

The INSERT Process The INSERT keyword is used to add data to an already existing table. The simplified syntax looks like this. Remember that square brackets in these syntax statements mean optional sections. INSERT฀ ฀฀[฀INTO฀]฀ ฀฀{฀฀ ฀} ฀฀[฀(฀column_list฀)฀]฀ ฀฀{฀VALUES฀(฀(฀{฀DEFAULT฀|฀NULL฀|฀expression฀}฀[฀,...n฀]฀)฀[฀,...n฀]) ฀฀|฀derived_table฀ ฀฀|฀execute_statement฀ ฀฀|฀DEFAULT฀VALUES฀

Let’s turn our attention back to the SandBoxDB database that we used earlier in this chapter. We created a table called Customer in that database. If you need to flip back a few pages to reacquaint yourself with this table, go ahead and do that now, as we will be working with this table over the next few sections. Our first step will be to add a row to this table. Because the CustomerID column supports the IDENTITY property, we will be able to ignore that column for now. To insert a row into the table, we might use a statement like this: USE฀SandboxDB; INSERT฀INTO฀dbo.Customer VALUES฀(‘The฀Computer฀Store’,฀‘PA’,฀1000);

This is the simplest form of the INSERT statement. We do not have to specify the columns into which we are inserting the data as long as we insert them in the same order as they are listed in the table. Because the CustomerID column automatically gets its values from the IDENTITY property, we can skip that column. Although we do not have to provide column names, it would be a best practice to do so, because it makes the code more adaptable to changing schemas and also makes it easier to understand. This also allows you to omit columns if needed. For example, the credit limit column allows null values. If you did not want to provide a credit limit, your code would look like this. USE฀SandboxDB; INSERT฀INTO฀dbo.Customer฀(CustomerName,฀StateCode) VALUES฀(‘RAM฀Warehouse’,฀‘OR’);

Performing an insert operation using a VALUES list works just fine, but if you look back at the syntax statement, you will see that you also have the option of using a derived table. This format allows you to do everything that you can do with a VALUES list, and provides additional

MODIFYING DATA

|

flexibility to insert data into a table based on more complex extraction rules. For example, you could rewrite this code using this syntax. Note the use of the two sequential single quotes to represent one single quote within a quoted string. USE฀SandboxDB; INSERT฀INTO฀dbo.Customer฀(CustomerName,฀StateCode) SELECT฀‘Buffalo฀Bill’’s฀Boot฀Shop’,฀‘WY’;

In this example, the SELECT statement returns two literal values in a derived table that will be inserted into the Customer table. What if we want to insert data into this table based on data from another table in this or another database? This is where the derived table form of the INSERT statement really shines. Suppose we have an Employee table in our database. (We don’t, so just pretend for a moment.) Suppose further that we want to add all of our employees as customers and give each one a $500 credit limit. If we have only two or three employees, then it will not be difficult to write two or three INSERT statements that use VALUES to perform each insert. But what if there are 2,000 employees? As long as the data that we need is in an Employee table, we can do it all with the following query: USE฀SandboxDB; INSERT฀INTO฀dbo.Customer฀(CustomerName,฀StateCode,฀CreditLimit) SELECT฀FirstName฀+฀‘฀‘+฀LastName,฀StateCode,฀500 FROM฀Employee;

Now it does not matter how many employees are in the table. They will all be inserted into the Customer table in one statement. This technique is extremely useful for loading temporary table structures with data from the database for further processing. Because this form is inclusive of the functionality that you would get from using the VALUES statement, it is a generally accepted best practice to use this form for all INSERT operations. A corollary of this syntax is that you can also use a stored procedure to provide the data for the insert operation, as long as the procedure returns the data in the correct order and datatype as required by the first line of the INSERT statement. Now let’s suppose that you had a stored procedure called GetEmployeeList that returned the needed data from the employee table. You could use this statement to load the data into the Customer table. You can read more about stored procedures in Chapter 5, “Procedural Programming.” USE฀SandboxDB; INSERT฀INTO฀dbo.Customer฀(CustomerName,฀StateCode,฀CreditLimit) EXEC฀GetEmployeeList;

Inserting with a CTE Previously, we saw that you can create a CTE from which you can subsequently select data. You can also insert, update, and delete data from the CTE. However, you must perform all actions on the CTE before executing the GO statement and ending the batch, because at that point the CTE falls out of scope and is no longer available. In this respect, the CTE acts very much like a table variable.

123

124

| CHAPTER 4

TABLES AND CRUD OPERATIONS

So far, we have been avoiding the IDENTITY฀column in our inserts, relying instead on the property to provide the next available value. But what if we need to insert a value into this column to maintain data integrity? For example, suppose that you want to use the EmployeeID column from the Employee table as the CustomerID in the Customer table to provide consistency between these two tables. You would not be allowed to insert the value into the CustomerID column until you told SQL Server that you were going to provide your own information for that column using the IDENTITY_INSERT statement. The syntax would look like this. USE฀SandboxDB; SET฀IDENTITY_INSERT฀Customer฀ON; GO INSERT฀INTO฀dbo.Customer฀(CustomerID,฀CustomerName,฀StateCode,฀CreditLimit) SELECT฀EmployeeID,฀FirstName฀+฀‘฀‘+฀LastName,฀StateCode,฀500 FROM฀Employee; SET฀IDENTITY_INSERT฀Customer฀OFF; GO

Note that if you want to insert a NULL value explicitly into a table, assuming that the column in question accepts NULLs, you can use the keyword NULL in the SELECT list of the derived table. If the column selected in the derived table contains a NULL, it will use that value on insert. If there is an alternative default value defined by a constraint, that value can be explicitly inserted using the DEFAULT keyword in your derived table or VALUES list.

The DELETE Process Deleting data from a table is a simple process in Transact-SQL. The basic form of the syntax looks like this. DELETE฀ ฀฀[฀FROM฀฀[฀,...n฀]฀]฀ ฀฀[฀WHERE฀฀][;]

Suppose that you want to delete all of the rows from the Customer table with which you have been working. This simple statement will do the trick. USE฀SandboxDB; DELETE฀FROM฀Customer;

That’s it. It doesn’t get much simpler than that, does it? But how often will you want to delete all of the entries in a table? Maybe sometimes, but there is a better way to do that and we will talk about it later in this chapter. Usually you will only want to delete some of the data in the table. That means your DELETE query must have a WHERE clause to provide criteria. Suppose, for example, that you want to delete every customer with a credit limit below 500. You would use a query like this one. USE฀SandboxDB;DELETE฀FROM฀Customer WHERE฀CreditLimit฀฀@param ORDER฀BY฀Price฀DESC;

Chapter 15

Transactions and Locking Business systems are complex. Frequently, data modifications that take place in one area of the database must occur concurrently with modifications made somewhere else. These processes must occur transactionally to ensure that you maintain data integrity. Transactional operations follow the ACID formula, which states that all transactions should be atomic, consistent, isolated, and durable. The “I” in ACID stands for isolated, which means that the data impacts of one transaction will influence no other transaction until the isolated transaction completes, either by committing or rolling back. SQL Server enforces isolation through its locking architecture. Locks on resources prevent operations in this shared data environment from interfering with each other, which is critical for data integrity. Data integrity is critical for your business, and maintaining this integrity is complicated by the activities of multiple users in the same data space. Although SQL Server will handle the locking process for you, these locks can have significant performance impacts on your server activity. Understanding and manipulating transactional behavior and locks is, therefore, critical to your ability to tune database and server performance. In this chapter, you will learn to: •u฀ Understand and utilize the SQL Server locking architecture •u฀ Implement an effective transaction management strategy •u฀ Implement an effective distributed transaction strategy •u฀ Get transaction and locking information

The SQL Server Locking Architecture There is a reason that almost every book or class on database administration or development deals with these two topics together. They are almost impossible to separate. Transaction activity has a direct relationship with locking. The types of actions in the transaction plus the duration of the transaction will determine which locks it holds and the level of contention for resources that those locks create. Conversely, the current status of the locks determines transaction performance, deadlocking, and other characteristics that can restrict overall database throughput. We will begin this chapter by looking at the locking architecture. In later sections of this chapter, we will see how that architecture impacts transactional behavior. There are a variety of different resources that SQL Server can lock and a number of different kinds of locks that it can hold. Each locked object and lock type plays a distinct role in the system. In this section, we will learn how the locking system works, then learn how to apply this knowledge to manage these resources and their concurrency effectively.

444

| CHAPTER 15

TRANSACTIONS AND LOCKING

The Chicken or the Egg Discussing transactions and locks can be a bit difficult because you need to understand one concept to understand the other. The whole discussion is conceptually recursive. We have to start somewhere, so we will start with locking. We will assume that you already understand the basic concepts of transactions. If you need a refresher, look back to Chapter 5, “Procedural Programming,” where we introduced transactional concepts. Feel free to skip back and forth in this chapter between the concepts of transactions and locking. At the conclusion of the entire discussion, the dust will settle and you should be able to see the whole picture more clearly.

What Gets Locked SQL Server is a collection of resources. Most of these resources are shared, meaning that many users could be trying to access the same resources at the same time. To complicate matters further, many shared resources are hierarchical. For example, a database is a resource that a user may need. If that user is using a database, you do not want another user to attempt a databaselevel action, such as a drop or restore of the database. However, databases contain tables. If another user works with a table, they are also implicitly working with the database. To extend this concept, a user reading a single row of data is also using the data page on which the row resides. The table contains the page, and the database contains the table. Therefore, SQL Server not only has to manage the locking for the actual consumed resource, but also the locking or potential locking for all of the other objects in the entire hierarchy. This set of locks is often called the lock chain, which refers to all of the locks necessary to ensure isolation of any specific resource at a particular level of hierarchy in the database. Table 15.1 provides a list of resources that the data engine is able to lock. You can find this list in the SQL Server Books Online under the topic of Lock Granularity, which organizes the resources from the most local and granular (RID) to the most global and least granular (database).

Table 15.1

Lockable Objects

Object

Description

RID

A row identifier used to lock a single row within a heap

Key

A row lock within an index

Page

An 8KB data or index page in a database

Range

A set of resources locked to prevent new inserts within the set

Extent

A set of eight contiguous pages

HoBT

A heap or a B-Tree used to protect data heap structures or index structures

Table

An entire table including all data and index pages

File

A database file used to allocate physical storage to a database

THE SQL SERVER LOCKING ARCHITECTURE

Table 15.1

Lockable Objects

|

(continued)

Object

Description

Allocation Unit

Sets of extents usually devoted to storing either in-row data or large object (lob) resources

Database

The entire database

PHYSICAL VERSUS LOGICAL The artifacts in Table 15.1 can be broken down into two categories: physical structures and logical structures. Physical structures are those associated with the physical allocation of space for database objects. Examples include allocation units, extents, and files. Logical structures deal with the logical organization of data in a database. These structures include the RID, key, and table. Physical structures generally lock for different reasons than logical structures, so it is important to make the distinction. Physical structures lock when SQL Server modifies the physical data structure or the allocation of that data structure. For example, if the database administrator (DBA) enlarges a database by increasing the size of a data file, the file will lock before the process begins and will release when the process completes. Likewise, if an allocation unit is allocated to a database when the database enlarges or if SQL Server allocates an extent to a table or index, those resources will lock as well. This prevents the allocation and configuration problems that can occur if two processes attempt to concurrently allocate or modify the same artifact. Logical structures lock when data modifications require the lock for protecting data integrity. The action taken will determine the level in the hierarchy at which the lock will occur. For example, a data modification to an individual row will usually activate a RID lock, while a build of a clustered index will lock the entire table with a single table lock. Pages are interesting artifacts in that they seem to have characteristics of both physical and logical structures. While pages are physical in that a page represents a physical block of 8KB of disk space or memory, SQL Server uses them like logical structures. Once SQL Server allocates an extent to a table or index, that table or index effectively owns all of the pages on the extent. The table or index uses the pages as needed and can lock them when data modifications that affect that page take place.

OVERHEAD VERSUS CONCURRENCY To manage resource consumption, sometimes called overhead, SQL Server can lock objects at different levels of granularity. Every SQL Server lock uses roughly the same overhead, whether that lock manages a row or the entire database. It is possible that instead of using different levels of locks, SQL Server could use only low-level locks, but that would dramatically increase overhead. For example, if a table has 100,000 rows and you want to build a clustered index on that table, SQL Server could use 100,000 row locks to manage concurrency and resource contention. Alternatively, SQL Server could use one table lock, which would employ less overhead by a factor of 100,000. The data engine must evaluate the trade-offs and make the best choice. The goal is to reduce overhead, while increasing concurrency. The more granular the lock, the more total overhead will be needed to manage those locks, but the more concurrency the server will support. Imagine that you designed a database engine that used byte locks. Every byte of data in the database is potentially lockable. If two users modify the same row, even the same field in

445

446

| CHAPTER 15

TRANSACTIONS AND LOCKING

a row, they would not interfere with each other as long as they did not modify the same actual byes of data. Is this solution possible? Perhaps, but it is not reasonable. While concurrency in this system would be phenomenal, the overhead would be outrageous. By contrast, you could also design a system that had a single database lock. Any time a user wanted to perform any action in the database, the system would require them to acquire the database lock first and release it when completed. This would significantly reduce locking overhead; in fact, it would be virtually nonexistent. However, this is also an impractical solution in a multi-user database environment because it does not allow for any user concurrency.

Managing the Trade-Off To help better manage the trade-off between overhead and concurrency, SQL Server uses a process of dynamic lock escalation. Once the server grants a certain proportion of finer grain locks, it can escalate the request to a coarser grain lock to benefit overhead at a potential concurrency cost. The logic is that as the quantity of fine grain locks that the server grants goes up, the probability of causing a contention problem due to lock escalation goes down. We will discuss this process in greater detail later in this section.

Types of Locks In addition to supporting different granularities of locks, the SQL Server locking architecture also supports numerous types of locks for different situations. Some locks are stricter than others. For example, two transactions attempting to read the same data at the same time does not cause the same level of exposure to corruption as two transactions writing to the same data structure at the same time. This distinction is reflected in the type of lock that SQL Server activates in any given situation. Not all objects can use all kinds of locks. Some locks are specific to physical structures, while others are specific to logical structures. Still others might only be relevant to a certain type or class of object. Table 15.2 lists the most common types of locks. This is not a complete list, but it shows the lock types that you will need to understand to effectively manage the locking infrastructure in SQL Server. For a more complete listing, consult the Lock Modes topic in the SQL Server Books Online.

Table 15.2

Lock Types

Lock Type

Description

Shared

Set when executing a statement that will not modify data, such as a select operation

Exclusive

Set when executing a data modification statement

Update

Set during update operations; that allows shared locking in the read phases of an update with an exclusive escalation for modifications

Intent

Set on coarser grain artifacts in a lock hierarchy to prevent integrity problems at different grains and to allow escalation if needed

THE SQL SERVER LOCKING ARCHITECTURE

|

Each lock type is used in specific situations and has certain levels of compatibility with other locks. Understanding lock behavior and compatibility is essential to managing lock contention and throughput. Let’s look at each of these types and their compatibility in greater detail. Shared Locks Shared locks are essentially “read” locks. Whenever an operation reads, but does not modify, data, it assigns a shared lock. Shared locks are markers that signify that a transaction is reading the resource, so no one can make changes until the transaction releases the lock. Shared locks are compatible with other shared locks, allowing more than one transaction to read a given block of data concurrently. SQL Server commonly places shared locks on the RID, page, or table artifacts as needed based on the operation and the level of escalation. Exclusive Locks Exclusive locks are “write” locks. Whenever a data modification occurs, SQL Server places exclusive locks on the resources that it modifies. Exclusive locks are not compatible with any other lock type. A shared lock can prevent the placement of an exclusive lock, as can another exclusive lock. If the resource is already locked, the transaction will wait for the lock to be released so that it can continue. This is called blocking. Because shared locks are more compatible than exclusive locks, they are less likely to cause blocking. Update Locks These locks are acquired in situations when an update operation requires multiple passes through the data to manage the update process. For example, depending on the complexity of the UPDATE statement or the modified columns, it might be necessary for the database engine to make a read pass through the data to identify the rows that must update prior to performing any actual updates. This is where the update lock is convenient. The update lock is a hybrid. It starts its life as a shared lock during the initial read process. During this read operation, before the updates occur, there is no reason to prevent other transactions from also performing data reads. After identifying the rows that it must modify, the data engine will escalate to an exclusive lock to execute the actual modifications. Hence the update lock is compatible with shared locks or other update locks in the read stage, but incompatible with any other locks in the write stage. Intent Locks Technically, the intent lock is not really a lock at all, but a lock marker. It plays two roles. First, it acts as a marker to tell a transaction that other resources at a finer granularity are locked and that it must wait accordingly. For example, if you have locked a RID exclusively pending an update, it will also set an intent lock at the page level and the table level. This will prevent another transaction from performing a table-level operation, such as dropping the table or building a clustered index on the table. The lock indicates that this would affect a finer-grain resource below and the table operation must wait until the initial transaction releases the intent lock. Second, it also marks a potential intent to escalate the lock in the future. Any lock on a RID may be escalated to the page level or the table level. Without an intent lock marking its intention, it might not be possible to escalate this lock when needed. To control this behavior, intent locks support subtypes including intent shared and intent exclusive. These subtypes indicate the type of down-chain lock the intent lock supports. Table 15.3 shows a compatibility matrix for the most common types of locks.

447

448

| CHAPTER 15

TRANSACTIONS AND LOCKING

Table 15.3

Lock Compatibility Matrix IS

S

U

IX

X

Intent Shared (IS)

Yes

Yes

Yes

Yes

No

Shared (S)

Yes

Yes

Yes

No

No

Update (U)

Yes

Yes

No

No

No

Intent Exclusive (IX)

Yes

No

No

Yes

No

Exclusive (X)

No

No

No

No

No

Controlling Locks Although you cannot turn off locking entirely, there are many things that you can do to control lock behavior. In most cases, you will want to let SQL Server manage locks for you. The data engine optimizes locking to provide the optimal balance among three competing factors: data integrity, overhead, and concurrency. Whenever you try to manipulate any of these factors, it will likely come at the cost of something else. You can control locking through three different mechanisms. These are database configurations, locking hints, and transaction isolation settings.

DATABASE CONFIGURATIONS THAT AFFECT LOCKING Locking may not be appropriate in all situations, but there is actually a database option that you can use to essentially turn off locking. Although there is no miracle switch labeled “Disable Locking” anywhere in SQL Server, the Database Read-Only option will have this effect if you can live with the consequences. Figure 15.1 illustrates the database properties dialog where you can configure this option. Notice the section labeled “State” in the bottom right of the dialog. If you cannot modify the data in a database in any way, there is no need to hold any locks on logical data structures. Rather than set shared locks, the Database Read-Only option disables the logical data structure locking chain altogether. Yes indeed; this option will do just what it says; it will mark your entire database as read-only. Of course, the side effect of this action is that you will not be able to modify the data. Although this sounds like an unreasonable restriction, there may be times that it makes sense. For example, suppose that you have a warehouse or a reporting system that you update periodically. Perhaps you use batch updates every evening to update the database using SQL Server Integration Services packages or Bulk Insert operations. In these cases, the database might be truly read-only most of the time, especially during operating hours when disabling the lock could really help performance. You could switch this option off before your update and back on when the update completes. This is a specialized case, but it shows that there are times when the options are valid.

THE SQL SERVER LOCKING ARCHITECTURE

|

Figure 15.1 Configuring the database options

TRANSACT-SQL LOCKING HINTS When you write your Transact-SQL (TSQL) code, you can include hints that provide specific instruction to the data engine about how to manage locks. Although they are called hints, they are really more like commands. Using hints, you can do things like: •u฀ Request a particular lock type •u฀ Request that no locks be held •u฀ Request a specific lock granularity •u฀ Request other specific locking behaviors

The syntax for most locking hints is the same. In the body of your TSQL statement, you can indicate the type of lock you want to request or the lock behavior that you want by using the WITH฀(Hint) statement, as in this snippet: USE฀AdventureWorks2008; SELECT฀*฀ FROM฀Person.Person฀WITH฀(TABLOCK) WHERE฀LastName฀LIKE฀‘K%’;

This hint requests that SQL Server use a table lock rather than following the default, which would be to use RID locks unless the optimizer determines an escalated lock would be a better option. This is just one of many hints that you can use to fine-tune the locking behavior in SQL Server.

449

450

| CHAPTER 15

TRANSACTIONS AND LOCKING

Table 15.4 provides a list of additional useful hints. This list is not complete. For additional options, look up the topic Table Hints in the SQL Server Books Online.

Table 15.4

Locking Hints

Hint

Description

HOLDLOCK

Requests that the lock will be held for the duration of the entire transaction. Identical to SERIALIZABLE.

NOWAIT

Indicates that the query should return immediately if blocked and return an error.

NOLOCK

Requests that no locks be requested or honored.

PAGLOCK

Requests that page locks be held where RID or table locks would normally be held.

READPAST

Instructs the query to ignore any locked pages or rows instead of blocking and waiting for locks.

ROWLOCK

Requests that RID locks be held and does not permit lock escalation.

SERIALIZABLE

Requests that the lock will be held for the duration of the entire transaction. Identical to HOLDLOCK.

TABLOCK

Requests that a table lock be held instead of escalating through RID and page locks.

TABLOCKX

Works just like TABLOCK except that it creates an exclusive table lock.

UPDLOCK

Requests that an update lock be held until the transaction completes.

XLOCK

Requests an exclusive lock where shared or update locks would normally be held.

You can use hints in combinations by placing the hints in a comma-separated list. For example, if you wanted to request a table lock and you also wanted to force the query to return immediately upon encountering a locked table, you could use this syntax: USE฀AdventureWorks2008; SELECT฀*฀ FROM฀Person.Person฀WITH฀(TABLOCK,฀NOWAIT) WHERE฀LastName฀LIKE฀‘K%’;

If your query requires a join between multiple tables, you can use different hints for each by placing the hint after the table reference in your query. If you use a table alias in your query, you should put the hint after the alias. This syntax shows an example: USE฀AdventureWorks2008; SELECT฀FirstName,฀LastName,฀EmailAddress FROM฀Person.Person฀as฀p฀WITH฀(NOLOCK) INNER฀JOIN฀Person.EmailAddress฀AS฀e฀WITH฀(TABLOCK,฀READPAST) ฀ ON฀p.BusinessEntityID฀=฀e.BusinessEntityID WHERE฀p.LastName฀LIKE฀‘K%’;

THE SQL SERVER LOCKING ARCHITECTURE

|

Danger Ahead In theory it sounds like a great idea. You can control concurrency and even other optimizer behavior, such as index selection and join order, simply by using some little hints in your code. In practice, it quickly becomes a wasp’s nest of maintenance problems. Not only are you exposing yourself to potential data integrity issues, but you are also taking away the data engine and query optimizer’s ability to tune and manage concurrency in the database. Once you start hinting, it is no longer “hands off” because when you insist that the data engine do one thing in a certain way, it loses the ability to manage the big picture effectively. Be especially careful of hints like the NOLOCK. It can cause integrity problems because it allows the data engine to read locked rows and pages. The bigger problem is that it is often a symptom of a poor database design. If you have to use NOLOCK statements to keep the database accessible, it may be a red flag that there are more substantial problems.

TRANSACTION ISOLATION LEVELS Remember that the “I” in ACID stands for isolated. One of the four standard characteristics of a transaction is that it is isolated from other transactions. One transaction should never interfere with or be aware of the work of another transaction. Locks enforce this isolation. Transaction isolation is something that you can control. By using database connection statements, you can specify how isolated a transaction will be. The ANSI standard defines four levels of transaction isolation. Read Uncommitted The data engine allows a transaction to read resources that another transaction is modifying but has not yet committed. This is sometimes called a “dirty read.” SQL Server provides for this behavior in a transaction by requesting no shared locks and honoring no exclusive locks. The behavior is the same as using a NOLOCK hint on every table at this level of isolation. Read Committed This is the default level of isolation. At this level, the transaction cannot read resources on which another transaction currently holds incompatible locks. Additionally, the transaction will place appropriate locks on all resources that it uses. The transaction typically holds shared locks only while the transaction reads the resource, while exclusive locks persist through the duration of the transaction. Repeatable Read This isolation level states that any read operation performed by a transaction should be repeatable later in the transaction. In other words, if you read a data row at the beginning of the transaction and again at the end of the transaction, as long as you do not modify the row in the transaction, those reads should yield the same result. To accomplish this, the transaction holds shared locks for the duration of the transaction instead of releasing them after reading the resource. This prevents the resources from being modified by operations outside of the current transaction. Serializable This level states that the transaction is completely isolated. It acts the same as repeatable read with regard to shared locks, but it also acquires range locks on read operations to prevent phantom reads, which are inserts that can occur within a range of resources that that the transaction is reading. Phantom reads result in the row counts of two serial reads being different because another transaction has inserted resources into the range read by the first transaction.

451

452

| CHAPTER 15

TRANSACTIONS AND LOCKING

In addition to these ANSI isolation levels, SQL Server 2008 also supports a non-ANSI option called snapshot isolation. In this option, data modifications made by other transactions after the start of the current transaction are not visible to statements executing in the current transaction. The effect is to give the statements in a transaction a “snapshot” of the committed data as it existed at the start of the transaction. Except when a database is being recovered: •u฀ SNAPSHOT transactions do not request locks when reading data. •u฀ SNAPSHOT transactions reading data do not block other transactions from writing data. •u฀ Transactions writing data do not block SNAPSHOT transactions from reading data.

Before you can use snapshot isolation, you must enable the ALLOW_SNAPSHOT_ ISOLATION option at the database level. Due to the overhead in maintaining a snapshot record of all modified data, this option is disabled by default. To enable this option, use this statement. ALTER฀DATABASE฀AdventureWorks2008 SET฀ALLOW_SNAPSHOT_ISOLATION฀ON;

Like most other SET statements in TSQL, the transaction isolation statements are session-level in scope. Once you set the option, it will be valid for the remainder of that session (user connection) until you close the connection or reset the setting to a different value. For example, to execute a series of queries allowing dirty reading, you could use a script like this one: USE฀AdventureWorks2008; SET฀TRANSACTION฀ISOLATION฀LEVEL฀READ฀UNCOMMITTED; GO SELECT฀FirstName,฀LastName฀FROM฀Person.Person; SELECT฀City,฀StateProvinceID฀FROM฀Person.Address; GO

In the previous snippet, you may have noticed that you must execute the isolation-level change with a GO statement before the change will take affect. The resulting behavior of these two select statements is identical to the result of placing the WITH฀(NOLOCK) statement in each query. Altering the transaction isolation level or using lock hints will give you more control over the concurrency of the application. However, every alteration of isolation has its price. Increasing concurrency generally reduces data integrity protection and the reverse is also true. You will need to find that delicate balance between the two extremes. Generally speaking, as a best practice, do not override these settings unless there is a verifiable reason to do so.

Managing Deadlocks Deadlocks are the bane of every database professional, but they are difficult to avoid altogether. When you are working in a multi-user environment, you will eventually run into a situation where the users will block each other. Knowing how to handle this is an important part of keeping your database up and responsive to user requests. Deadlocks occur when two or more users need to use resources that are locked by other users before they can continue with their process. What separates this from simple blocking is its reciprocity. For example, assume that User A has row 1 locked and now needs to read row 2. However, User B has row 2 locked. This would be a simple blocking scenario. User A waits for User B to release the lock, and then it can continue.

TRANSACTION MANAGEMENT

|

What can cause a deadlock is when User B needs to get access to row 1 before it can complete and release its lock. Think about this. The only way that User A can continue is if User B completes or rolls back. User B is in exactly the same situation. At this point, neither of them can continue and one of them must cancel their transaction. SQL Server deals with deadlocks in a very heavy-handed manner. It kills whichever connection has done the least amount of work up to that point. This is based on the overhead of undoing the work of the connection. SQL Server does not attempt to predict which connection is closest to completing, only which one can be cancelled the fastest and with the least overhead. Once identified, it will kill this connection immediately. There are two ways that you can deal with deadlocking. The simplest way is to be disciplined in your code to ensure that all resources are accessed in the same order all the time. For example, if our two users both started by locking row 1 and then requested the lock for row 2, subsequently, this would merely be a blocking situation rather than a deadlock. One user would never deadlock another because it would never hold a resource lock out of order. The other approach is a little more drastic. You can allow a connection to volunteer to be the victim of a deadlock. If you have a very low-priority connection that is deadlocking and causing the cancellation of other high-priority connections, you can configure the low-priority connection to be killed no matter how much work it has done to that point. You would accomplish this by using a session statement as follows. SET฀DEADLOCK_PRIORITY฀LOW;

This indicates that the connection has a very low priority to continue when it deadlocks with another connection, essentially volunteering it to be the victim. Please note that the query timeout option has no affect on deadlocking because SQL Server does not wait for a timeout to complete before killing the necessary connection. Once SQL Server detects a deadlock situation, it will kill that connection immediately.

Transaction Management Although you can use techniques such as hinting and changing isolation levels to tune locking, the most important consideration is how you manage your transactions. The duration of a lock is generally associated with the transaction in which the data interaction takes place. Not managing your transactions effectively can cause significant performance degradation and misunderstanding transaction behaviors will lead to data integrity problems. In this section, we will look at basic transaction concepts and then see how we can code to optimize transaction behavior.

SQL Server Transaction Concepts You will remember from the discussion in Chapter 5, “Procedural Programming,” that transactions are SQL statements, usually resulting in data modifications of some sort, that are aggregated into the smallest possible unit of data integrity. The statement or set of statements must complete in its entirety or not at all. It must not interfere with or rely on the work of other executing transactions, and the results of the transaction must be durably recorded. SQL Server supports two general types of transactions: implicit and explicit. Implicit Transactions These are transactions that are automatically started when certain operations take place, such as an INSERT, UPDATE, or DELETE statements. Implicit transactions do not need any transaction identifiers to be supplied by the query. They begin automatically due to the type of command that the query executes.

453

454

| CHAPTER 15

TRANSACTIONS AND LOCKING

Implicit transactions generally work in an auto-commit mode, meaning that as soon as the transaction operation completes, it will commit without any user intervention. For example, if a user executes a DELETE statement against the database that may affect multiple rows, the entire operation will occur as a transaction even though only one statement executed. If one of the deletes fails, the entire set will fail. Explicit Transactions These are the transactions that you request using a BEGIN฀ TRANSACTION marker in your TSQL code or by using a transactional API call from your client application. Following the command to begin a transaction, all TSQL statements that are valid inside the context of a transaction will be considered elements of the transaction until it is either committed or rolled back by the caller, or the connection terminates, which results in a rollback of any open transactions.

Controlling Auto-Commit Behavior SQL Server’s auto-commit behavior is not the standard in the industry. It is common for a relational database management system to use a system of implied transaction markers rather than an autocommit behavior. For example, instead of performing the previously mentioned delete operation in an auto-commit mode, the DELETE statement would cause an explicit transaction to begin that would have to either be committed or rolled back at the conclusion of this and/or other subsequent operations. Database professionals who are transitioning to SQL Server from other systems may be more accustomed to this alternative behavior. If you want SQL Server to assume this behavior, you can control it through the session statement SET฀ IMPLICIT฀TRANSACTIONS฀ON. This session-scoped statement will cause any use of the following statements to begin a transaction that must be explicitly committed or rolled back: •u฀ ALTER฀TABLE

•u฀ INSERT

•u฀ CREATE

•u฀ OPEN

•u฀ DELETE

•u฀ REVOKE

•u฀ DROP

•u฀ SELECT

•u฀ FETCH

•u฀ TRUNCATE฀TABLE

•u฀ GRANT

•u฀ UPDATE

Implementing Explicit Transactions Explicit transactions begin when a BEGIN฀TRANSACTION statement executes in a SQL statement. When this occurs, SQL Server places a transaction marker in the transaction log so that it can locate the recovery point if necessary. Once the transaction is formally committed, all of the transaction log records will immediately flush from the data cache to disk, thus rendering the transaction permanent.

TRANSACTION MANAGEMENT

|

There are a number of different forms that this process can take. You can use a simple transaction statement like this one: BEGIN฀TRANSACTION; DELETE฀FROM฀table1; DELETE฀FROM฀table2; COMMIT฀TRANSACTION;

If you like, you can abbreviate the word “transaction” like this. BEGIN฀TRAN;

You can also name a transaction if you wish. Named transactions can make it easier to understand your code and in some cases can also make it easier to recover from a backup. To use a named transaction, use this code: BEGIN฀TRAN฀DemoTran; --฀statements COMMIT฀TRAN฀DemoTran; --฀or฀ROLLBACK฀TRAN฀DemoTran

You can also place a mark in the transaction log with a named transaction that will make it simple to recover to that point again using the STOPAT option when restoring a log. The name of the transaction will be the stop at point. To add the mark, use this syntax. BEGIN฀TRAN฀DemoTran฀WITH฀MARK;

It is possible to nest named transactions, but this really buys you nothing because only the outermost transaction is registered with the system for rollback. For example, consider the following code snippet. USE฀AdventureWorks2008; BEGIN฀TRAN฀T1; SELECT฀COUNT(*)฀FROM฀Person.Person; BEGIN฀TRAN฀T2; SELECT฀COUNT(*)฀FROM฀Person.Person; ROLLBACK฀TRAN฀T2;

Conceptually, T2 is nested within T1, so a rollback to T2 should only roll back the work that was done from the beginning of T2 to the rollback point. However, if you execute this query, you get an interesting error message that reads like this. Msg฀6401,฀Level฀16,฀State฀1,฀Line฀6 Cannot฀roll฀back฀T2.฀No฀transaction฀or฀savepoint฀of฀that฀name฀was฀found.

This is a curious message, because we explicitly created a transaction named T2. However, because that transaction was nested inside T1 and only the outer transactions were registered with the system, it is literally as if the transaction point never existed. If you commit or roll back a transaction, it will commit or roll back all the way to the outermost transaction. This does not mean that nested transactions are not recognized at all. They certainly are. It is just that you cannot roll back or commit to any point other than the outermost transaction point. For example, try rewriting the previous query just a little and see what you get.

455

456

| CHAPTER 15

TRANSACTIONS AND LOCKING

Now execute the following statement in a new connection, ensuring that there are no open transactions before the process begins. You should get interesting results. USE฀AdventureWorks2008; BEGIN฀TRAN฀T1; SELECT฀@@TRANCOUNT; BEGIN฀TRAN฀T2; SELECT฀@@TRANCOUNT; ROLLBACK฀TRAN฀T2;

The @@TRANCOUNT global variable tells us how deeply nested the current transaction is. If you execute this snippet in a fresh connection, the first counter should return 1 and the second should return 2. This means that SQL Server has, in fact, recognized the beginning of the nested transaction, but it did not allow rollback or commit to that point in the hierarchy. What good are nested transactions if you cannot commit or roll back to those points? The real answer is that explicit transaction statements were never meant to be nested within a single script, and this is a misuse (and often a dangerous misunderstanding) of transactional behavior. Most nested transactions end up that way due to modular procedure structure. For example, if one stored procedure begins a transaction and then calls another procedure that also begins a transaction, you now have a nested transaction. As you can imagine, this can be dangerous. If the called procedure were to roll back its transaction for some reason internal to the procedure, it would have an impact that extended beyond its control. The transaction that called the procedure would also be rolled back, and any executing statements that followed would then be in a nontransactional state. In this case, the called procedure should consult the value @@TRANCOUNT before rolling back its transaction to ensure that it would not affect anything out of its control.

Using Savepoints Because nested transactions do not give you the ability to partially commit a transaction, there is another option. You can use a savepoint. Savepoints are markers in a transaction that represent points of integrity. Using a savepoint marks that the transaction is potentially safe to commit to that point, even if additional work is pending. Figure 15.2 illustrates the use of savepoints.

Figure 15.2

BEGIN TRAN T1

Using savepoints

A D

SAVE TRAN S1

F

B E

SAVE TRAN S2 C --Add End Tran Logic

TRANSACTION MANAGEMENT

|

In this diagram, you will see one BEGIN marker with two SAVE markers. At the end of the transaction, the statements that you use will determine what SQL Server will commit or roll back. For example, if you were to use the statement COMMIT฀TRAN฀T1, it would commit all of the work indicated by bracket F in the diagram. But what if halfway down the transaction you realize that you cannot commit the whole transaction? Perhaps the first part of the transaction would be safe to commit, but the last part is not. You can use a savepoint if you can identify the cutoff point for the commit in advance. In this example, we defined a savepoint called S1. Suppose that after executing additional statements, you determine that you cannot commit anything after the savepoint. You might use this logic at the end of the transaction: ROLLBACK฀TRAN฀S1; COMMIT฀TRAN฀T1;

These statements would roll back all of the work executed in bracket E in the diagram, and then subsequently commit the work in bracket A. Likewise, if you were to roll back to S2 instead of S1, you could undo the work in bracket C, followed by a commit of the work in bracket D. Now consider the previous situation where one stored procedure calls another. If the called stored procedure might need to roll back any of the work that it is doing, it could use a savepoint instead of a nested transaction statement. Then if needed, it could roll back to the savepoint instead of rolling back the entire transaction. Because the called procedure rolls back only its own work, the calling procedure is never even aware that SQL Server had extended and then reversed the transaction. It can continue as if nothing had happened.

Transactions from Outer Space Everyone has a good transaction story. This one comes from the consulting diary of Michael Lee. Transaction management in SQL Server is not difficult from a TSQL code perspective. Beginning a transaction and testing for errors is a simple process. However, in a highly modularized data environment, it can be a bit of a challenge. It was just this situation that I ran into once when consulting for an entertainment retailer in the western United States. They had painstakingly crafted a procedural model intended for heavy reuse. In most cases, code reuse is a good thing. I’m all for it generally, but because their model relied on significant procedural chaining—where procedures frequently called other procedures—they ran into some significant transaction problems. They had done an excellent job in most of their procedures to ensure that problems resulting in transactions being rolled back and error codes being raised to the client. The problem was that when a rollback occurred in a procedure that was nested three or four layers down from the initial call, the rollback operations had impacts that went far beyond the aborted transaction. We experimented with numerous transactional approaches including savepoints, but nothing seemed to work just right for the situation at hand. As a DBA consultant, I felt it was time to take extreme measures.

457

458

| CHAPTER 15

TRANSACTIONS AND LOCKING

In a meeting with the senior DBA staff, I made what I thought was a reasonable suggestion. I suggested that they take out all of the transaction management from the stored procedures, leave the error management, which was working fine, and push the entire transactional process from the procedures to the Data Access Layer (DAL), which was written in C# with ADO.NET. From the reaction that I got, you would think that I had suggested that we all go bear hunting with sticks. In other words, my client responded with complete disbelief. Now I realize that most DBAs love to have complete control over the database. It is up to us to protect and ensure the integrity of the database, but transaction management to me is a little different. I have always felt that transactions are really nothing more than advanced business rules. And where do all of the business rules go? They go in the object tier, in this case, on the business side of the Data Access Layer (DAL). SQL Server has a perfectly good transactional API that can be fully leveraged from OLEDB or .NET. Taking advantage of it to solve this problem seemed like a natural solution. Even so, I will never forget a comment made by one of the DBAs at the time. He said that allowing developers to manage transactions is taking orders from creatures from outer space. Of course, my argument was that developers are responsible for a significant amount of the data integrity anyway by enforcing business logic at the component level. How is this any different? At the end of the day, we did a limited pilot of this concept and it worked beautifully. Developers don’t want data messed up any more than DBAs do. It is just that we DBAs tend to take it a little more personally. The moral of the story is that that there are many facets to SQL Server, although we do not always have to use them all. Consider all of the tools at your disposal, not just the ones that you are comfortable with. You will have many more options for making the best application possible.

Transactions and Errors Transactions are usually closely related to errors, because in most cases, unless a transaction component can complete without error, you should not commit that transaction. We discussed the specifics of dealing with errors in Chapter 5, so we will not repeat those here, but it is very important to consider the topic of errors concurrently with the topic of transaction management. You have already read about TRY and CATCH statements. These statements can be very useful when managing transactions because they give you the opportunity to roll back transactions if they do not successfully complete in their entirety. Consider the following transaction. DELETE฀FROM฀table1; DELETE฀FROM฀table2;

As it exists right now, this represents two independent implicit transactions. To ensure that they commit or roll back together, you must add transaction markers like this: BEGIN฀TRAN; DEELTE฀FROM฀table1; DELETE฀FROM฀table2; COMMIT฀TRAN;

TRANSACTION MANAGEMENT

|

This code would enable both transactions to be committed if possible, but there is still a possibility that the first DELETE statement could fail and yet the second would commit. Because there is no error handling, if the first statement fails, SQL Server would simply continue to the second statement, committing it if possible. To prevent this, you must tell SQL Server to detour around the second statement if the first statement cannot commit. Consider this revision to the code. BEGIN฀TRY BEGIN฀TRAN; ฀ DELETE฀FROM฀table1; ฀ DELETE฀FROM฀table2; ฀ COMMIT฀TRAN; END฀TRY BEGIN฀CATCH ฀ ROLLBACK฀TRAN; END฀CATCH

There’s More to the Catch This example is admittedly a bit simplistic. In addition to simply rolling back the transaction, you may want to raise an error to the client or capture other information—such as the error number or error description—to a log. Feel free to pad this out as necessary so that all information is communicated as necessary. Don’t forget the three “R’s” of transactional processing: RaiseError, Rollback, and Return. You may also want to check the value of XACT_STATE(), which is a system function that will tell you if the transaction can be safely committed. This function returns -1 if it cannot be safely committed and should be rolled back. A return of 0 indicates that you are not in the context of a transaction and either a commit or rollback would result in an error. If it returns 1, the transaction can be safely committed. This is a useful function to use if you are unsure about the state of the transaction and what you can do with it.

Concurrency and Performance For all the problems that transactions can solve with regard to data integrity, they can create just as many problems relating to concurrency and performance. It is critical that you consider these issues when planning your transactional strategies as well as your lock isolation and hinting structure. Being aware of the problems is half the battle, though. Here are a few things that you might want to consider as you are designing your transactional infrastructure. Keep transactions short. The longer the transactions are, the longer you will hold locks, and (usually) the more data you will lock. Make sure that you do any processing before you start the transaction. Do not start the transaction until you are prepared to execute the operations required by the transaction and then get out as quickly as possible. It is up to you to make sure that your locking does not become blocking.

459

460

| CHAPTER 15

TRANSACTIONS AND LOCKING

Assume transactions will commit. The performance assumption in SQL Server is that transactions will commit. Once the transaction begins, you are executing work that SQL Server assumes you will want to commit. Before you begin the transaction, do all you can to give the transaction the best chance possible of committing. Then you will not have to deal with rolling back the work that could not commit, which is a very high overhead process. Use more concurrent isolation levels. Don’t be afraid of a dirty read. You should assume that transactions will commit; therefore, you should also be able to safely assume that the data that you are reading will ultimately be committed. Although you may run into a few consistency issues from time to time, dealing with those issues often uses less overhead than holding locks and blocking out or deadlocking other users. Access only necessary data. Try not to access more data than you really need. This is primarily an issue when selecting data. Use effective WHERE clauses and try to filter out as much of the data as possible. Not only will you improve the select performance and reduce disk and network I/O, but you will also be reducing the resources that you have to lock, which will increase concurrency on the server side. This is an easy thing to do that is usually underestimated by most developers. Keep it short and simple. No user interaction. This is a holdover from the old xBase days, but you might be surprised at how much the authors see this issue when tuning applications. Do not begin a transaction and then enter a user interactive mode. You never know what the user is going to do or how long they will take. You lose complete control of transaction duration when the transaction does not commit until the user hits that Save button. Instead, don’t even begin the transaction until you have all of the information you need to perform the task at hand. Use implicit transaction mode with caution. If you come from another database system that used implicitly started transactions, you might be used to that pattern. If yours is primarily a SQL Server background, be careful. You can get very used to working with auto-commit behaviors and sometimes you don’t remember that when the implicit transaction mode is enabled, once you commit or roll back a transaction, the very next statement probably starts another one. If you do not manage this process, transactions tend to get very long and brittle.

Distributed Transactions The way that SQL Server manages transactions places a limitation on standard transactions. SQL Server can only enforce standard transactions on a single server. For example, a transaction that uses multiple tables in a single database or even across multiple databases on the same server is no problem for a standard transaction. However, if you want to include resources on a different server, then you can no longer use a standard transaction. In this case, you must use a distributed transaction. SQL Server’s standard data engine installation includes a tool called the Distributed Transaction Coordinator (DTC). This utility is responsible for maintaining the integrity of distributed transactions in a SQL Server environment. You can think of the DTC as a “traffic cop,” responsible for managing the interaction among the various data engine instances that participate in the transaction. The mechanism that the DTC uses to do this is called a two-phase commit protocol. As its name implies, it breaks each distributed transaction into two separate phases called prepare and commit.

DISTRIBUTED TRANSACTIONS

|

The Prepare Phase The initial phase of the two-phase commit requires each service that participates in the transaction to enlist in the transaction and complete the work assigned to it. The DTC will contact every participating instance, enlist them in the transaction and verify their ability to participate. Then the DTC will give each instance the work that it must complete. The instance executes the work of the transaction but does not commit the work yet. Each service reports its ability to commit back to the DTC and awaits the second phase. The Commit Phase After enlisting the services in the transaction, the DTC waits for each service to report back its ability to commit. Each service must report back in a timely manner and must indicate that it is able to commit its work. Reporting must be unanimous. If any server does not respond or returns a condition that would prevent the transaction from committing, the DTC sends an abort message to all participants and they all roll back their work. If all participants indicate an ability to commit, the DTC sends a commit message and all services commit together.

Watch Your Overhead Although distributed transactions sound great in concept, you really need to watch the overhead. There is a significant amount of communication that must take place to keep all of the participants in sync. There is also a lot of data that will be moving back and forth among the participants. Consider this as part of your overall distribution strategy. Another issue to consider is the fact that for each service you enlist, you will be creating a point of failure. Even one service failure will cause all distributed transactions that use that service to fail as well, which may interfere with the work of other servers in your enterprise data infrastructure. If you are using distributed transactions to synchronize distributed data, you may want to consider other options that do not have this point-of-failure weakness, such as replication or log shipping. Those techniques can often provide the features that you need without the potential costs. Chapter 12, “Data Availability and Distribution,” addresses these features in detail.

Understanding Distributed Queries Up to this point, our examples have shown queries that execute on a single server and usually in a single database. It is possible, however, to distribute query behavior across multiple database and even multiple servers. Before we can turn our attention to distributed transactions, however, we must discuss the process of performing server-to-server communications using distributed queries. There are two ways that you can execute distributed queries across servers. One approach is to use the OpenRowset() function and the other is to use linked servers.

USING THE OpenRowset() FUNCTION The OpenRowset() function is primarily a method for performing queries against a target server on an ad hoc basis. Each call using OpenRowset() is self-contained and includes everything that the query needs to know to make the connection and execute the query. The function makes all connectivity through OLEDB and, therefore, this option is available to all OLEDB-

461

462

| CHAPTER 15

TRANSACTIONS AND LOCKING

compliant data sources. You are not limited to SQL Server data sources. The basic syntax of the OpenRowset() function looks like this. OPENROWSET฀ ( {‘provider_name’, {‘datasource’;’user_id’;’password’|’provider_string’}, {[฀catalog.][schema.]object|’query’}} )฀

You will note that there are three parameters for the function. The first is the name of the OLEDB provider that you will use to connect to the remote service. If you are connecting to another SQL Server 2008 service, use SQLNCLI as the provider name. This indicates that you will be using the SQL Native Client. Other services have OLEDB providers as well, so you will need to look into the documentation for those services and determine the appropriate name to use. The second parameter is a connection string that is provider specific. This contains the information about the target service and database as well as authentication information. The final parameter is the object that you wish to access. This could be a stored procedure that you want to execute or a pass-through query that you want to send to the service for execution. Before you will be able to use the OpenRowset() function, you must first configure the target server to allow ad hoc distributed queries. You can do this by executing the following configuration code on the target server. Note that because the Ad Hoc Distributed Queries option is an advanced Boolean option, you must execute the first statement before you will be able to make the required change. You should then set the option back when complete. EXEC฀sp_configure฀‘Show฀Advanced฀Options’,฀1; RECONFIGURE; EXEC฀sp_configure฀‘Ad฀Hoc฀Distributed฀Queries’,฀1; RECONFIGURE; EXEC฀sp_configure฀‘Show฀Advanced฀Options’,฀0; RECONFIGURE;

Now that you have permitted the use of the distributed query on the target server, you are free to execute the query. This example executes a query against an AdventureWorks2008 database on a distributed server instance. Note that you would be executing this query from the context of the server instance called “Tuthmosis,” but the pass-through query will actually execute on the service instance called “Tuthmosis\DTCTarget.” SELECT฀DISTINCT฀dtc.FirstName,฀dtc.LastName FROM฀OpenRowset( ฀ ฀ SQLNCLI’, ฀ ฀ ‘server=tuthmosis\DTCTarget;database=AdventureWorks2008;฀ ฀ ฀ trusted_connection=yes’, ฀฀฀ ‘SELECT฀FirstName,฀LastName฀FROM฀Person.Person’ )฀AS฀dtc WHERE฀dtc.LastName฀LIKE฀‘K%’;

This example is very selective with regard to the columns that it returns from the target server, but not the rows. There are no filter criteria executing on the target server. What you see here is actually two separate queries. One query is the pass-through that executes on the target server, and the other filters out the data on the local server in the outer query. Keep in mind that

DISTRIBUTED TRANSACTIONS

|

you are running multiple queries because you will want to tune each one to make sure that you are conserving bandwidth and I/O as much as possible. This example also uses integrated security. The assumption is that the user is logged into the primary server using a Windows account that also has access to the target server. If this is not the case, you may get a login error when attempting to execute the query.

CONFIGURING LINKED SERVERS The other option for executing a distributed query is to configure a linked server. While an ad hoc query provides authentication information every time a call to OpenRowset() executes, the linked server model will store all authentication and resolution information in the server’s configuration data. This facilitates the use of the linked server by allowing a four-part name for the resources that you want to access instead of having to use an ad hoc function with each execution. You can add a linked server to your configuration by using either a TSQL statement or the studio interface. The visual interface displays all required and available options, so we will use that approach. You can script the results of the visual configuration, however, if you need to create the same linked server reference on multiple servers in the enterprise. To begin, open the SQL Server Management Studio (SSMS) and expand the node for the server that will be the primary server. This server will host the query that will call the other services. Locate the Server Objects node inside your server list and expand this to find the linked servers list. You will also see a Providers list containing the different providers that SQL Server installs by default. You can create a linked server to any of the databases for which there is a provider. To create a linked server, right-click the Linked Servers node in the list on your primary server and select New Linked Server from the menu. This will display a dialog like the one illustrated in Figures 15.3 through 15.5. This dialog has three pages. The first page does the basic configuration, as shown in Figure 15.3.

Figure 15.3 Configuring Linked Server Connectivity

463

464

| CHAPTER 15

TRANSACTIONS AND LOCKING

In this dialog, the name of the linked server is DTCTARGET. This is an alias that points to the actual server instance, which is Tuthmosis\DTCTarget. This linked server uses the SQL Native Client interface. The next page in the dialog, pictured in Figure 15.4, configures linked server security.

Figure 15.4 Configuring linked server security

You have many options when configuring security. This dialog shows a standard integrated connection. SQL Server will use the same user account that you use to log into the primary server to log into the target server. This interface allows a very flexible security configuration. You can start by doing specific login mapping in the top section. This will allow you to map a local login to another specific remote login. Then for all local logins that are not in the top list, you can select one of the four options visible at the bottom of Figure 15.4. These options will (in order) •u฀ Deny access •u฀ Permit access under guest authority •u฀ Permit access under trusted authority •u฀ Permit access using a specific general account

The final page in the dialog, pictured in Figure 15.5, provides the linked server options. You can change these options at any time, along with the security options in the previous dialog, by accessing the linked server properties after the link has been created. If you want detailed information for each option, click the Help button at the top of the dialog for a full discussion. For now, just verify that the Data Access option is set to True. This option must be enabled before you will be allowed to use the linked server in a distributed query. When you are finished with this page, click the OK button to create the linked server.

DISTRIBUTED TRANSACTIONS

|

Figure 15.5 Linked server options

Now that you have created the linked server, you can use that link in a distributed query. There are two ways to do this. The first is to use a standard four-part name in the FROM clause of the query. This will force the target server to return the entire data structure from the target server where the primary server can continue to filter and process the data. For example, consider the following query. SELECT฀*฀FROM฀DTCTarget.AdventureWorks2008.Person.EmailAddress WHERE฀ModifiedDate฀>=฀‘01/01/2000฀00:00:00.000’;

This query returns the entire content of the Person.EmailAddress table from the target server to the primary server, which applies the filter criterion and returns the results to the requesting user. This is a very convenient syntax, but if the target table is quite large, or if there are data that cannot be returned to the primary server, such as an XML column, you will need to find an alternative approach. For example, take a look at this query. SELECT฀FirstName,฀LastName FROM฀DTCTarget.AdventureWorks2008.Person.Person WHERE฀LastName฀LIKE฀‘K%’;

If you execute this query, you will get an error message stating that xml data types are not supported in distributed queries. Looking at the query, this seems a little odd, because you are returning only FirstName and LastName, and neither of these columns is configured as an xml data type. Remember, though, that when you use the four-part name in a query, the target server will return the entire data structure to the primary server for processing.

465

466

| CHAPTER 15

TRANSACTIONS AND LOCKING

You can solve this problem in two different ways. One is to use stored procedures or views on the target server instead of accessing the table directly. This will force some execution on the server. Simply use the four-part name of the desired procedural target to access it through the linked server. Use the view name in the FROM clause in place of the table names. Stored procedures will execute as normal with an EXECUTE statement using a four-part name for the procedure. The other option is to use the OpenQuery() function. This function provides for a passthrough query to be sent to the target server, much like OpenRowset(), but through the linked server rather than on an ad hoc basis as with the OpenRowset() function. To use the OpenQuery() function, try this syntax. SELECT฀dtc.FirstName,฀dtc.LastName FROM฀OpenQuery( ฀฀DTCTarget, ฀฀‘SELECT฀FirstName,฀LastName฀ ฀฀FROM฀AdventureWorks2008.Person.Person’ )฀AS฀dtc WHERE฀dtc.LastName฀LIKE฀‘K%’;

Although it is a little more work, you can optimize your linked server queries using this method rather than using a simple four-part name. The performance and security prize still goes to stored procedures in most cases, though, so you should definitely consider that as an option before you default to using OpenQuery().

Making Distributed Modifications You can use OpenQuery() to make data modifications as well. By using the OpenQuery() function in place of a table name in an INSERT฀UPDATE and DELETE statement, the data modification will be targeted to the data subset as defined in the OpenQuery() syntax. You can also use this syntax as part of a distributed transaction, making this a very flexible option when needed.

Defining Distributed Transactions Once you have created the linked servers, you have completed the real work of configuring distributed transactions. SQL Server handles most of the nuts and bolts of making a distributed transaction work. By defining the linked servers, you have created all the necessary target configurations and set up the required security. Now all you have to do is request the distributed transaction. There is one configuration option that you might want to check. If you open the Database Properties dialog and go to the Connections page, you will see a dialog like the one pictured in Figure 15.6. Toward the bottom of this dialog is an option that allows you to specify that any server-to-server communication is required to execute using distributed transactions. This is a safety mechanism that you can enable to ensure that multiple servers will stay in sync so one cannot inadvertently execute a remote operation outside the context of a distributed transaction. Be careful of the overhead, though. This option can be a real stinger. We will leave this unchecked for now.

DISTRIBUTED TRANSACTIONS

|

Figure 15.6 Database configuration for distributed transactions

Requesting a distributed transaction rather than a standard transaction is a very simple process. Just use the statement BEGIN฀DISTRIBUTED฀TRAN to begin the transaction. Everything else will behave normally. Consider the following snippet as an illustration. USE฀AdventureWorks2008; BEGIN฀TRY BEGIN฀DISTRIBUTED฀TRANSACTION; UPDATE฀OpenQuery( ฀ ฀ DTCTarget, ฀ ฀ ‘SELECT฀BusinessEntityID,฀FirstName ฀ ฀ ฀ FROM฀AdventureWorks2008.Person.Person ฀ ฀ ฀ WHERE฀BusinessEntityID฀=฀1’ ฀ ) SET฀FirstName฀=฀‘Kenny’ WHERE฀BusinessEntityID฀=฀1; UPDATE฀Person.Person SET฀FirstName฀=฀‘Kenny’ WHERE฀BusinessEntityID฀=฀1; COMMIT฀TRANSACTION; END฀TRY BEGIN฀CATCH ฀ ฀ ROLLBACK฀TRANSACTION; END฀CATCH

467

468

| CHAPTER 15

TRANSACTIONS AND LOCKING

This code executes a distributed transaction on the Adventureworks2008 database on both servers. The goal of this distributed transaction is to keep the two databases in sync by ensuring that any modification made to one database will also be made automatically to the other database. This, of course, requires that the DTC be installed and running, because it will act as the transaction manager in this situation, enlisting the DTCTarget server in the transaction and ensuring that the modification commits to both servers or not at all.

Getting Transaction and Locking Information Fortunately for the DBA, the lock chain is not invisible. You can get valuable information from SQL Server about processes and locks when you need it. This information will not only help you understand SQL Server’s behaviors, but will also let you use these techniques for tuning queries, managing blocking and deadlocking activity, and managing user processes. You can get access to much of this information by using either the SQL Server Management Studio or Transact-SQL code. This will be an important part of your role as a SQL Server database administrator. You must always be aware of the current server activity, watching for problems so that you can be proactive before they occur. In this section, we will cover some of the more common tools in your arsenal.

Using the Activity Monitor Utility The Activity Monitor utility is accessible through the Management Studio interface. To locate it, connect to the server you want to monitor using the Object Browser and expand the server node. You will see a Management node that contains other nodes and some items. One of the items is the Activity Monitor. If you double-click on the Activity Monitor icon, a dialog like the one pictured in Figure 15.7 will appear. The Activity Monitor utility allows you to look at current activity in three ways: Process Information, Locks by Process, and Locks by Object.

Figure 15.7 The Activity Monitor

GETTING TRANSACTION AND LOCKING INFORMATION

|

The dialog currently shows the Process Info page, where you can see all of the server processes (SPIDs) and their current statistics. This window will tell you who your users are, where they are connecting from, and how they are connecting, as well as the current transactional status. This dialog can be forced to refresh periodically, or you can filter out the content of the window as desired. The links in the Status box on the left of the dialog support these behaviors. The other pages in the dialog display locking information, which you can view on a process or object basis depending on your needs. For example, suppose that you execute the following statement inside a transaction. DELETE฀FROM฀pubs..TempAuth;

If the transaction has not yet committed, there will be an Intent Exclusive lock on the table TempAuth. If you were to look at the Locks by Object page of the Activity Monitor, it would look like figure 15.8. Note the type of lock listed in the Request Mode column is marked as IX, meaning an intent exclusive lock.

Figure 15.8 The Locks by Object page

Using Transact-SQL to Monitor Activity You can also use TSQL code to get similar information. In particular, the system stored procedures sp_lock and sp_who provide very useful information regarding locking and blocking. Figure 15.9 illustrates the sp_who stored procedure, which returns process information. Note that SPID฀54 is the process from the previous example. It is currently active but not performing any work, rather, it is simply awaiting a command.

469

470

| CHAPTER 15

TRANSACTIONS AND LOCKING

Figure 15.9 Using sp_who

You can also get locking information like that available from the Activity Monitor by using the sp_lock procedure. Figure 15.10 illustrates the use of this procedure. Notice the locks held for SPID฀54. There is a shared lock on the database. In addition, because we are deleting numerous rows from the table, we have exclusive locks on each row. Note that there are intent exclusive locks at the page level as well as the table level. The entire set of locks makes up the lock chain for this particular SPID.

Figure 15.10 Using sp_lock

THE BOTTOM LINE

|

There are also some system views that provide similar information but organize it in different ways. To monitor locking, user activity, and optimizer activity, you should utilize these specific views: •u฀ sys.dm_exec_connections •u฀ sys.dm_exec_query_optimizer_info •u฀ sys.dm_tran_current_transaction •u฀ sys.dm_tran_locks

Other views are available, but this list is a good place to start. You may want to explore the list of system views and look for names that are interesting and pertinent to your current task. Doing so is a great way to become more familiar with your options.

The Bottom Line Understand and utilize server locking architecture. Understanding locks and their relationships to transactions is a critical part of managing a SQL Server data environment. Although SQL Server handles all locking automatically for you, you can also get information about locks and transactions through the visual interface and through Transact-SQL code. Knowing why certain locks are held at certain times and being familiar with their compatibility with other locks will also help you manage concurrency. Master It For each scenario, identify the lock type that will most likely be used to satisfy the scenario.

1. Select a few rows from a table. 2. Restore a database backup. 3. Rebuild a clustered index. 4. Rebuild a nonclustered index. 5. Delete all rows in a table. 6. Select a range of rows in a table using serializable isolation. Implement an effective transaction management strategy. Effective transactions make the difference between a consistent database and a heap of junk. The SQL language supports a strict transactional construct and through the SQL Server transaction log, complete ACID transactions are a reality. Master It Describe the SQL Server auto-commit behavior and explain why it is important in designing a transactional solution. Implement an effective distributed transaction strategy. In the larger enterprise, data will be distributed and so, therefore, transactions must also be distributed. Ensuring the integrity of distributed transactions is an important part of any enterprise data architecture.

471

472

| CHAPTER 15

TRANSACTIONS AND LOCKING

Master It Explain the difference between the following approaches for querying a remote server:

1. OpenRowset() 2. OpenQuery() 3. Linked server query with four-part name reference Get transaction and locking information. Even though SQL Server manages the locking infrastructure for you, it is still frequently necessary to extract information about current transaction and locking status to troubleshoot transaction or locking problems. There are numerous tools available for accessing this information. Master It What are some of the tools that you can use to extract transaction and locking information from SQL Server?

Chapter 16

Using the Resource Governor and Policy-Based Management SQL Server 2008 is quite a bit more robust in its management than previous versions of SQL Server. The Resource Governor allows an administrator to allocate different amounts of server resources to different applications. This can allow you to better balance varying workloads on a large SQL Server installation. In addition, policy-based management makes it much easier to verify and configure SQL Server settings according to policies. A policy can be evaluated against many servers at once, and many violations can be reconfigured directly from the policy interface. In this chapter, you will learn to: •u฀ Use the Resource Governor to manage and balance varying workloads •u฀ Use policy-based management to define, evaluate, and enforce a desired configuration

The Resource Governor Have you ever had an application that liked to hog system resources? How about an employee who occasionally produced long-running queries that had a major effect on other applications running on the server? Both of these problems can make it difficult to ensure adequate performance for all users of a SQL Server instance. With consolidation becoming the norm, it is becoming more common to see many databases with varying performance requirements being run on the same server. The Resource Governor is a new feature of SQL Server 2008 that can help you more granularly allocate server resources to different types of connections. It works by classifying incoming connections into different workload groups, which can each be individually monitored and tuned. A workload group is contained inside of a resource pool that allows division of overall memory and CPU resources for an instance. There are several benefits to enabling and using the Resource Governor on a SQL Server 2008 instance, including: •u฀ It allows monitoring of individual workload groups and resource pools using performance

counters to better understand resource usage by application. •u฀ It makes it possible to prioritize one workload over another. •u฀ It allows you to provide a guaranteed minimum percentage of memory and CPU resources

for a resource pool.

474

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

•u฀ It lets you set a limit on the maximum percentage of memory and CPU usage for a

resource pool. •u฀ It makes it easier to run many applications with differing resource and performance

requirements on the same SQL Server instance without allowing one to have an adverse impact on the others. Figure 16.1 shows the different types of related objects involved in using the Resource Governor. The three main components are workload groups, resource pools, and a classification function.

Figure 16.1

Incoming Connections Copy

The Resource Governor architecture

System Processes

Classification Function

Workload groups

groupApp2

Resource Pools

User Pool

groupApp1

default

default

internal

internal

When connections are made to a SQL Server that has the Resource Governor enabled, a classification function is called to determine in which workload group the session should be placed. The classification function is a user-defined scalar function in the master system database. It contains logic to return the name of the workload group based on information about the connecting session. It can use several system functions to retrieve information about the connecting session, including: •u฀ APP_NAME() •u฀ HOST_NAME() •u฀ IS_MEMBER() •u฀ SUSER_NAME(),฀SUSER_SNAME() •u฀ LOGINPROPERTY() •u฀ ORIGINAL_DB_NAME() •u฀ CONNECTIONPROPERTY()

Because the classification function is called in each new session, it is critical that it performs well. A poorly designed classification function can cause connections to time out. You can diagnose classification problems by using the Dedicated Administrator Connection, or by starting SQL Server in single-user mode.

THE RESOURCE GOVERNOR

|

Workload groups are useful for monitoring the activity, CPU, and memory consumption of a given set of sessions. Workload groups can be used to categorize sessions by application, or by purpose, such as reporting sessions. A workload group can be individually monitored, tuned for CPU and memory usage, and can also be given a relative importance to other workload groups in the same resource pool. Initially, there are two workload groups: default and internal. The default workload group is used for all incoming sessions that don’t have a specific, valid workload group name returned from the classification function. The internal workload group is used for all internal sessions and processes that connect to SQL Server, and it can’t be used for user sessions. The internal workload group cannot be modified, but it can be monitored. Resource pools are used to divide server resources for consumption by different workload groups. This is accomplished by providing ranges of memory and CPU resources that can be consumed by workloads in the resource pool. This can allow you to limit the maximum percentage of memory or CPU consumed by the workload groups. It can also allow you to guarantee that a minimum percentage of CPU and memory is available for workload groups in the pool. Two resource pools initially exist: internal and default. A workload group is always part of a single resource pool. If a resource pool isn’t specified when a workload group is created, the default resource pool is used. The overall process for using the Resource Governor usually looks something like this:

1. Create workload groups for each application or area you would like to evaluate. 2. Create a classification function to classify each session into a workload group. 3. Configure the Resource Governor to use the classification function, and enable the Resource Governor.

4. Monitor the Resource Governor performance counters to better understand the workloads on the SQL Server.

5. Create resource pools to allocate specific server resources to workloads if required. 6. Tune workload group performance by specifying a relative importance, CPU, and memory limits.

7. Continue to monitor the workload group and resource pool performance counters to ensure that tuning is working as expected.

Workload Groups The first step in utilizing the Resource Governor is deciding which workload groups to create. Workload groups are usually created by application, but they might be created by purpose or by a group of users. So long as you are able to differentiate the connections using Transact-SQL, you can separate them into a workload group. You might have a SQL Server that is heavily used for several applications, including an accounting application, a CRM application, and a reporting application. You may want to give priority to one application over another one, or you might want to set limits on the amount of resources one of these applications can consume. Before you set limits, you will want to understand the characteristics of the workloads. It’s a simple process to create workload groups. The code shown in Listing 16.1 creates three workload groups that we will use for our examples. All of these workload groups will be initially contained in the default resource pool.

475

476

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

Listing 16.1

Creating Workload Groups

CREATE฀WORKLOAD฀GROUP฀groupAccounting; CREATE฀WORKLOAD฀GROUP฀groupCRM; CREATE฀WORKLOAD฀GROUP฀groupReports;

In order to use the workload groups we’ve created, we will need to create a classification function and configure the Resource Governor to use it. The classification function will return the name of the workload group in which the session should be placed. Listing 16.2 shows the classification function we’ll be using for our example.

Listing 16.2

Creating a Classification Function

USE฀master; GO CREATE฀FUNCTION฀dbo.fn_RGClassify() ฀RETURNS฀SYSNAME฀WITH฀SCHEMABINDING AS BEGIN ฀฀DECLARE฀@ResourceGroupName฀sysname; ฀฀IF฀(APP_NAME()฀LIKE฀‘%Accounting%’) ฀฀฀฀SET฀@ResourceGroupName฀=฀‘groupAccounting’; ฀฀฀฀ ฀฀IF฀(APP_NAME()฀LIKE฀‘%CRM%’) ฀฀฀฀SET฀@ResourceGroupName฀=฀‘groupCRM’; ฀฀฀฀ ฀฀IF฀(SUSER_SNAME()฀=฀‘DOMAIN\ReportingGroup’) ฀฀฀฀SET฀@ResourceGroupName฀=฀‘groupReports’; ฀฀฀฀ ฀฀RETURN฀@ResourceGroupName; END

Once a classification function has been created, we need to configure the Resource Governor to use the classification function. This is accomplished using the statements shown in Listing 16.3.

Listing 16.3

Specifying a Classifier Function and Enabling the Resource Governor

ALTER฀RESOURCE฀GOVERNOR WITH฀(CLASSIFIER_FUNCTION=dbo.fn_RGClassify฀ ALTER฀RESOURCE฀GOVERNOR฀RECONFIGURE;

At this point, the Resource Governor is configured and ready to monitor. It’s important that we monitor our workload before tuning so that we can better understand its characteristics. The SQL Server: Workload Group Statistics performance object provides counters for monitoring information about each workload group. Each workload group is shown as an instance of the

THE RESOURCE GOVERNOR

|

Workload Group Statistics performance object. Table 16.1 shows the counters available for monitoring workload groups.

Table 16.1

SQL Server: Workload Group Statistics Performance Counters

Counter Name

Description

Queued Requests

The number of requests waiting to be picked up from the queue. This will be nonzero if the GROUP_MAX_REQUESTS limit is reached and throttling occurs.

Active Requests

The current number of running requests. You can also retrieve this value by counting the rows in sys.dm_exec_requests and filtering by group ID.

Requests Completed/sec

Cumulative number of requests completed/sec in this workload group.

CPU Usage %

CPU bandwidth usage for all requests in this workload group relative to the computer and normalized to all CPUs. This value changes as the amount of CPU available to the SQL Server Process changes. It isn’t normalized to what the SQL Server process receives.

Max Request CPU Time (ms)

Maximum CPU time by a request currently running in the workload group.

Blocked Requests

Number of blocked requests in a workload group.

Reduced Memory Grants/sec

Number of queries that are getting less than the ideal amount of memory grants per second. Useful for determining workload characteristics.

Max Request Memory Grant (KB)

Maximum value of a memory grant for a query. Useful for determining workload characteristics.

Query Optimizations/sec

Number of optimizations in this workload group per second. Useful for determining workload characteristics.

Suboptimal Plans/sec

Number of plans per second generated in this workload group that are suboptimal.

Active Parallel Threads

Current number of parallel threads executing in the workload group.

For more information on using performance counters and system monitor, see Chapter 10, “Monitoring SQL Server Activity.” Once you’ve had a chance to monitor your workload, you can then use several workload group options to tune performance. The syntax for altering a workload group is shown here. ALTER฀WORKLOAD฀GROUP฀{฀group_name฀|฀“default”฀} [฀WITH ฀฀฀฀([฀IMPORTANCE฀=฀{฀LOW฀|฀MEDIUM฀|฀HIGH฀}฀] ฀฀฀฀฀[฀[฀,฀]฀REQUEST_MAX_MEMORY_GRANT_PERCENT฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀REQUEST_MAX_CPU_TIME_SEC฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀REQUEST_MEMORY_GRANT_TIMEOUT_SEC฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀MAX_DOP฀=฀value฀]

477

478

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

฀฀฀฀฀[฀[฀,฀]฀GROUP_MAX_REQUESTS฀=฀value฀]฀) ฀] [฀USING฀{฀pool_name฀|฀“default”฀}฀]

Table 16.2 describes each of the WITH options that can be specified when creating or altering a workload group.

Table 16.2

Workload Group WITH Options

Option Name

Description

IMPORTANCE

Relative importance of the workload group in relation to other workload groups in the same resource pool. Workload groups in other resource pools aren’t affected by this setting. Allowable values are HIGH, MEDIUM, and LOW. The default is MEDIUM.

REQUEST_MAX_MEMORY_GRANT_PERCENT

Maximum percentage of memory that a single request can take from the pool. The default value is 25 percent. A value over 50% can result in only one query being able to execute at a time.

REQUEST_MAX_CPU_TIME_SEC

Maximum amount of CPU time in seconds that can be used by a request. This won’t prevent a request from executing, but it will generate a trace event when the time is exceeded.

REQUEST_MEMORY_GRANT_TIMEOUT_SEC

Maximum time in seconds that a query will wait for a memory grant to become available. If this time is exceeded, a minimum memory grant will be used, which could result in less than optimum performance.

MAX_DOP

The maximum degree of parallelism for parallel requests.

GROUP_MAX_REQUESTS

The maximum simultaneous requests allowed to execute in the group. If the number of requests exceeds this amount, the requests are queued.

Resource Pools Resource pools make it possible to allocate different amounts of server resources to a workload group. They make it possible to divide the CPU and memory resources of a SQL Server instance. This can be accomplished by specifying a minimum and maximum percentage of memory and CPU that will be allocated to the resource pool. By default, there are two resource pools: default and internal. The default resource pool cannot be dropped, and any workload groups that don’t explicitly specify a resource pool use the default resource pool. You can alter the ranges specified in the default pool if needed. The syntax for creating a new resource pool is shown here: CREATE฀RESOURCE฀POOL฀pool_name [฀WITH

THE RESOURCE GOVERNOR

|

฀฀฀฀฀฀฀฀฀(฀[฀MIN_CPU_PERCENT฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀MAX_CPU_PERCENT฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀MIN_MEMORY_PERCENT฀=฀value฀] ฀฀฀฀฀[฀[฀,฀]฀MAX_MEMORY_PERCENT฀=฀value฀]฀) ]

Specifying a minimum percentage guarantees resource availability, but it also keeps other resource pools from using the reserved amount. If you had two resource pools, and one specified that it had a minimum of 25 percent CPU time, the other resource pool would have a true maximum amount of 75 percent of CPU time available for use, assuming that sessions are executing in both resource pools. This is because SQL Server always reserves 25 percent of the CPU time for workloads in the first pool, even if it could be used by the second resource pool. The totals of all minimum percentage values for all resource pools must add up to 100 percent or less. For example, you couldn’t have two resource pools that each are allocated a minimum of 60 percent of the resources. Specifying a maximum percentage allows you to keep sessions from consuming more than a certain percentage of memory or CPU resources. For example, you may want to ensure that reporting queries take up no more than 25 percent of the server memory. This could be accomplished by specifying a minimum of 0 percent and a maximum of 25 percent. Before tuning resource pool allocations, it is important to monitor the actual usage of resources. This can be accomplished by monitoring the SQL Server: Resource Pool Statistics performance object. The counters for this performance object are shown in Table 16.3. Each resource pool is an instance of this object. For more information on using system monitor and performance counters, refer to Chapter 10.

Table 16.3

SQL Server: Resource Pool Statistics Performance Counters

Counter Name

Description

CPU Usage %

CPU bandwidth usage for all requests in this resource pool relative to the computer and normalized to all CPUs. This value changes as the amount of CPU available to the SQL Server Process changes. It isn’t normalized to what the SQL Server process receives.

CPU Usage Target %

CPU usage target based on the current system load and resource pool configuration settings.

CPU Control Effect %

How much of an effect the Resource Governor is having on the resource pool. Calculated by dividing the CPU usage percentage to what the CPU usage percentage would be without using Resource Governor.

Compile Memory Target (KB)

Current memory broker target in KB for query compilations.

Cache Memory Target (KB)

Current memory broker target in KB for cache.

Query Exec Memory Target (KB)

Current memory broker target in KB for query execution memory grant.

479

480

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

Table 16.3

SQL Server: Resource Pool Statistics Performance Counters

(continued)

Counter Name

Description

Memory Grants/sec

Number of memory grants occurring per second in the resource pool.

Active Memory Grant Count

Total count of current memory grants.

Memory Grant Timeouts/sec

Number of memory grant timeouts/sec.

Active Memory Grant Amount (KB)

Total amount in KB of granted memory for the resource pool.

Pending Memory Grant Count

The number of requests for memory grants marked as pending in the queues.

Max Memory (KB)

Maximum amount of memory that the resource pool can have based on settings and server state.

Used Memory (KB)

The current amount of memory used for the resource pool.

Target Memory (KB)

The target amount of memory that the resource pool is trying to obtain based on server state and resource pool settings.

The diagram shown in Figure 16.2 describes our desired configuration for workload group and resource pool usage. We want to guarantee that at least 20 percent of CPU and memory resources are available for workload groups in the OLTP pool. For reporting, we want to make sure that the sessions never take up more than 50 percent of the memory and CPU resources on the server. Any other sessions will be in the default workload group which is a part of default resource pool.

Figure 16.2 A Resource Governor configuration

group Accounting priority Low

group CRM priority high

group Reports Request_Max_CPU_Time=45

Default

pool OLTP

pool Reports

default

min.cpu 20% max.cpu 100% min.mem 20% max.mem 100%

pool min.cpu 0% max.cpu 50% min.mem 0% max.mem 50%

min.cpu 0% max.cpu 100% min.mem 40% max.mem 100%

The range of available resource usage for our example is shown in Figure 16.3. The OLTP pool can take up as much as 100 percent of the total server resources, while the default pool can only take up to 80 percent of the resources because we specified a minimum of 20 percent for the OLTP pool.

THE RESOURCE GOVERNOR

Figure 16.3

pool OLTP

Available resource ranges for our resource pools

pool Reports Always available for pool OLTP (20%)

|

Maximum Usage for pool Reports (50%)

Potentially available for default Potentially available for pool OLTP

The code shown in Listing 16.4 creates the resource pools that we’ll be using for our example.

Listing 16.4

Creating Resource Pools

CREATE฀RESOURCE฀POOL฀poolOLTP ฀฀WITH฀(MIN_CPU_PERCENT฀=฀20,฀MAX_CPU_PERCENT฀=฀100, ฀฀฀฀฀฀฀฀MIN_MEMORY_PERCENT฀=฀20,฀MAX_MEMORY_PERCENT฀=฀100); ฀฀฀฀฀฀฀฀ CREATE฀RESOURCE฀POOL฀poolReports ฀฀WITH฀(MIN_CPU_PERCENT฀=฀0,฀MAX_CPU_PERCENT฀=฀50, ฀฀฀฀฀฀฀฀MIN_MEMORY_PERCENT฀=฀0,฀MAX_MEMORY_PERCENT฀=฀50);

Once we’ve created our resource pools, we need to alter the workload groups so that they are contained in the appropriate resource pool. Listing 16.5 shows the SQL statements required to perform this operation. This also sets workload importance so that sessions in the groupCRM workload group are a higher priority than sessions in groupAccounting. In addition, a SQL trace event (CPU Threshold Exceeded) will be generated whenever a session in the groupReports workload group exceeds 15 seconds of CPU usage.

Listing 16.5

Configuring Workload Groups to Use the Resource Pools

ALTER฀WORKLOAD฀GROUP฀groupAccounting ฀฀WITH฀(IMPORTANCE฀=฀LOW) ฀USING฀poolOLTP; ALTER฀WORKLOAD฀GROUP฀groupCRM ฀฀WITH฀(IMPORTANCE฀=฀HIGH) ฀USING฀poolOLTP ALTER฀WORKLOAD฀GROUP฀groupReports ฀฀WITH฀(REQUEST_MAX_CPU_TIME_SEC฀=฀15) USING฀poolReports; ALTER฀RESOURCE฀GOVERNOR฀RECONFIGURE;

481

482

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

Once the Resource Governor has been configured, it is important to monitor the performance objects to ensure that performance is working as expected. Any configuration changes must use the ALTER฀RESOURCE฀GOVERNOR฀RECONFIGURE statement before the changes will take effect.

Understanding Policy-Based Management It’s important to have your SQL Servers configured according to best practices. Microsoft published a tool for previous SQL Server versions called the SQL Server Best Practices Analyzer. It could scan one or more SQL Servers and evaluate their configuration according to predefined best practices, and produce a report of violations. It was a very useful tool for identifying any configuration-related problems without requiring a DBA to manually verify the settings on each of the servers they needed to administer. Microsoft has extended the concept of the Best Practices Analyzer to be a core component of SQL Server 2008 called policy-based management. The technology was previously called Declarative Management Framework during some of the beta editions of SQL Server 2008. Policy-based management makes it possible to define a policy that says how a particular area of SQL Server should be configured. This policy can be evaluated against one or more SQL Servers to produce a report of policy violations. Many of the settings that can be evaluated can also be configured directly from the report of policy violations. For example, suppose you define a policy that the AutoShrink Database option should be false for all databases. This policy can be evaluated against the databases on one or more SQL Servers to see which databases have the AutoShrink Database option enabled. From the violation report, you can apply the policy to selected databases to automatically turn off the AutoShrink Database option. There are also areas that can be evaluated that don’t directly map to a configuration setting. For example, you might want to ensure that all databases store their database and log files on separate disks. One of the properties that can be evaluated for a database is called DataAndLogFilesOnSeperateLogicalVolumes. The policy can highlight areas where the data and log files aren’t on separate logical volumes, but it can’t automatically configure SQL server to conform to the policy, because it doesn’t know on which logical volumes the data and log files should reside. Another example of a policy that can’t be automatically applied is one that verifies that a database has been backed up in the last seven days. We can identify databases that haven’t been backed up, but we can’t apply the policy to automatically back them up—more information is required in order to configure the backup job, backup storage locations, etc. All of the policies discussed so far need to be evaluated in order to be effective. These policies are usually evaluated on demand or on a schedule. Another possibility for some policies is to have the policy enforced by the SQL Server database engine. For example, you might want to ensure that all stored procedures in a database are named with the prefix of usp_. You can define a policy that specifies this rule, but you can also have it enforced by SQL Server whenever changes are made. Policies that are evaluated on change use either DDL triggers or event notifications to prevent or log any changes that violate policy. In order to create a policy that executes on change, it must be possible to capture the event using a DDL trigger or event notification.

UNDERSTANDING POLICY-BASED MANAGEMENT

|

One last example involves needing to configure many SQL servers in the same way. Policybased management makes it possible to export the configuration of a component as a policy, which can then be evaluated against other SQL Servers, to see where violations have occurred, and to automatically apply the appropriate configuration changes. Policy-based management can be useful to a database administrator in many ways, including: •u฀ The ability to evaluate the configuration of one or more SQL Servers against a policy •u฀ Being able to verify that a server is configured according to Microsoft best practices •u฀ Being able to configure many components directly from a policy violation report •u฀ The ability to export the current configuration of a component as a policy that can be used

to evaluate and configure other servers •u฀ Being able to enforce that certain types of additions and changes shouldn’t be made to cer-

tain databases, such as enforcing an object-naming scheme for a database

Policy-Based Management Components Policy-based management consists of several related components that work together. Figure 16.4 shows a diagram of the Policy-Based Management architecture. Policy-based management can be used to evaluate and configure nearly every aspect of a SQL Server. There are three main components to policy-based management: policies, conditions, and facets. These three components are used together to define the desired configuration of an area of SQL Server. A facet is a set of properties that model the characteristics of a managed target. For example, a database could be considered a managed target, and it has properties that map to things like the database recovery model, and other database configuration options, such as automatically creating statistics. The properties of a facet are used to create conditions that define how a property should be configured.

Figure 16.4 The Policy-Based Management architecture

Policy Check Condition Targets Evaluation Mode Server Filter Category

Condition Facet PropertyExpression(s)

Facet Managed property values

Managed Object

483

484

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

A policy must contain a check condition that uses the properties of a facet to define how an area should be configured. For example, you might create a condition that says the Recovery Model property of the database facet should be Full. The check condition is the main criteria that the policy is using for evaluation. While a policy can be created with a single check condition, you can also use other conditions to filter which areas the policy should apply to. For example, you might not want to have the policy apply to every database, or on every server. You can filter the managed targets that a policy applies to by using target filter conditions. You can also filter which servers the policy will apply to by creating a server filter condition. A policy can be evaluated in several different ways. You can evaluate a policy on demand, on a schedule, or for some policies, you can have them enforced when changes occur. We will cover policy evaluation modes in greater detail later in the chapter. A policy can be a part of a category. Not every policy will apply to every database on a SQL Server. Policy categories allow administrators of individual databases to determine the optional policies to which their databases should subscribe. A category can also mandate database subscriptions, so that it will apply to all databases on a SQL Server instance.

FACETS Facets are one of the core components of policy-based management. A facet maps to one or more managed targets, and it contains properties that relate to the target’s configuration. Seventy-four facets are included with SQL Server 2008. One of the first steps in understanding policy-based management is to see which facets and properties are available. You can view a full list of facets by expanding Management  Policy Based Management  Facets in the Object Explorer window. The Properties window of the database facet is shown in Figure 16.5.

Figure 16.5 The Database Facet Properties window

UNDERSTANDING POLICY-BASED MANAGEMENT

|

Many properties are available for the database facet. Each property is listed with a name and description. Some properties map directly to configuration settings that can be changed, and some are read-only and can only be used to evaluate configuration, rather than change it. For example, the Recovery Model can change for a database, but you can only read the Space Available property. To view the actual values of facet properties, you can right-click on an object (for example, a database) in the Object Explorer and choose Facets. A screen similar to the one in Figure 16.6 is displayed. Many of the properties can be configured directly from this screen if they aren’t grayed out. If a property is grayed out, it is only available to read from a policy, rather than change. A single, managed object may have many facets that apply to it. For example, the Database managed object has several facets, including Database, Database Options, Database Performance, and Database Maintenance. You can choose which facet to view by using the dropdown list shown at the top of the screen in Figure 16.6. Most facets map to a single managed target; however, some facets can apply to multiple types of managed targets. For example, the Multipart Name facet can be applied to a table, stored procedure, view, or other object that uses a multipart name. Later in the chapter, we’ll create a naming-convention policy that uses the Multipart Name facet. Figure 16.7 shows a diagram of some of the relationships between facets and managed targets.

Figure 16.6 The Database Facet property values

485

486

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

Figure 16.7 The relationships between facets and managed targets

Facets Server

Managed Targets Server

Server Information Server Security

Database

Database

Database Options Database Performance Data File

Table

Table

Table Options

Multipart Name Stored Procedure

View

Stored Procedure

View

CONDITIONS A condition is one or more expressions that use the property values of a facet. In order to create a condition, you must choose a facet for it to use, and then define expressions that express a desired state. For example, you might create a condition that specifies that the AutoShrink property of a database should be False. Figure 16.8 shows an example of such a condition. Conditions can be reused in more than one policy, so make sure to name them descriptively to promote reuse. A condition can contain one or more expressions that can be combined using the AND or OR operators. You can also create more complex expressions using the Advanced Condition Editor. Several functions are available when you use the Advanced Condition Editor, including ExecuteSql() and ExecuteWql() functions to execute SQL Statements and WQL (WMI Query Language) queries, respectively. An example of using the Advanced Condition Editor is shown in Figure 16.9. If you use the ExecuteSql() or ExecuteWql() functions in a condition, a warning is generated when the policy is evaluated telling the administrator that there is a script that could be potentially harmful. Make sure to review and verify that any script is legitimate, especially if using a policy received from a third party.

UNDERSTANDING POLICY-BASED MANAGEMENT

Figure 16.8 Creating a new condition

Figure 16.9 Using the Advanced Condition Editor

|

487

488

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

POLICIES A policy consists of a check condition to be evaluated against a set of targets. The targets available depend on the check condition. A condition that uses the database facet will have databases as the target. Other conditions can use multiple types of targets (for example, a condition using Multipart Name could apply to any targets that contain a multipart name). Figure 16.10 shows an example of a policy with multiple targets. Other conditions can be used to filter the targets to which the policy applies. By default, a condition that matches every managed target is used. You can also use a server-restriction condition to filter the servers to which the policy will apply. A server restriction can use any of the server-based facets to define a condition that must be met to evaluate the policy on a server. There are four possible policy-evaluation modes, depending on the type of conditions and targets selected: •u฀ On Demand •u฀ On Schedule •u฀ On Change: Log Only •u฀ On Change: Prevent

Figure 16.10 A policy that can have multiple targets

All policies can be evaluated on demand. Because the policy is evaluated using the SQL Server Management tools, an on-demand policy can be evaluated against SQL Server 2005 or SQL Server 2000 servers.

UNDERSTANDING POLICY-BASED MANAGEMENT

|

Policies that are evaluated on a schedule use SQL Server Agent jobs to automate policy evaluation. You must be using SQL Server 2008 to use any of the evaluation modes other than On Demand, because the policy must be stored on the server. When automating policy evaluation, the results are stored in the msdb system database. You can then use the Policy Health State button in Object Explorer to identify areas that don’t conform to policy. We will be covering policy health state later in the chapter. Some policies can be evaluated as changes occur. In order to create a policy that is evaluated on change, it must be possible to capture the event that causes the change by using either DDL triggers, or by using event notifications. The DDL triggers or event notifications used to enforce the policy are automatically maintained by the policy-based management framework. We will be creating policies that execute on change later in this chapter.

CATEGORIES Policies can be grouped into categories. Categories can help to organize policies on a server so that individual databases can subscribe to all of the policies in a category. A policy category can also be used to mandate database subscriptions, forcing all databases on the server to subscribe to all policies in a category. Figure 16.11 shows an example of using policy categories.

Figure 16.11

Databases

Categories

Policies

Understanding policy categories

Database 1

(Mandate Subscriptions)

Backup Policy

Database 2

production_policies

Not Autoshrink Full Recovery

Database 3

naming_policies

Table_Naming Sproc_Naming

In our example, three categories contain all the policies. The only category that mandates database subscriptions is the default category. This means that all of the databases on the server will have the backup policy applied. Database 1 doesn’t subscribe to any other policy categories, so the backup policy is the only one that applies to it. Database 2 uses both the production_policies category and the naming_policies category. All five policies will apply to Database 2. Database 3 uses only the naming_policies category, so three policies will apply to it: the backup policy and the two naming policies. When creating a policy, you specify the category it belongs to on the Description page of the Create Policy window. A policy can belong to only a single category. To manage the available policy categories, right-click on Policy Management in Object Explorer and choose Manage Categories. The dialog box shown in Figure 16.12 appears.

489

490

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

To change which policy categories apply to a database, you can right-click on the database in Object Explorer, and choose Policies  Categories. The dialog shown in Figure 16.13 appears, allowing you to choose which categories the database should use.

Figure 16.12 The Manage Policy Categories dialog

Figure 16.13 The Database Policy Categories dialog

UNDERSTANDING POLICY-BASED MANAGEMENT

|

Creating and Evaluating Policies Now that you understand the components of policy-based management, we’ll start to use it in practice. We’ll start by examining some of the policies that are packaged with SQL Server. We’ll see the different methods of evaluating policies, against one or more servers, and we’ll create policies with each of the evaluation modes.

IMPORTING MICROSOFT BEST PRACTICES Microsoft has included many of the best practices that were available with the SQL Server Best Practices Analyzer from previous versions of SQL Server. The best practices have been turned into policies that can easily be imported and evaluated against one or more servers. To use the Best Practices policies, you must first import them. You can find the policy XML files in the directory C:\Program฀Files\Microsoft฀SQL฀Server\100\Tools\Policies\ DatabaseEngine\1033. All of the best practices will execute on demand, by default. To import a policy, follow these steps:

1. Connect the Object Explorer to the SQL Server to which you would like to import the policies.

2. Expand Management  Policy Management. 3. Right-click on the Policies folder and choose Import Policy. The dialog shown in Figure 16.14 appears.

4. Click on the ellipsis to choose which policy files to import. You can choose more than one policy by using the Ctrl key. Microsoft Best Practices are located in C:\Program฀Files\ Microsoft฀SQL฀Server\100\Tools\Policies\DatabaseEngine\1033.

Figure 16.14 The Policy Import dialog

491

492

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

5. Choose a state (enabled or disabled) that imported policies should be placed in. The options are •u฀ Preserve policy state on import •u฀ Enable all policies on import •u฀ Disable all policies on import

6. Click OK to import the policies. Any policies and conditions contained in the XML file(s) will be imported. Many useful policies are included with SQL Server that you can use as is or modify to fit your requirements. All of the sample policies are evaluated on demand by default.

EVALUATING A POLICY Policies can be evaluated in several ways. In this section, we’ll look at evaluating policies on demand using SQL Server Management Studio. You can evaluate policies against SQL Server 2008, 2005, and 2000 servers when using evaluating policies on demand. Some properties are valid only for a specific version of SQL Server. We’ll begin by using the Database Auto Shrink policy that’s included with the Best Practice policies. This policy says that every online user database should have the AutoShrink property set to False. Evaluating the policy will compare the configuration of each database on the SQL Server to the policy. If there are policy violations, we can make configuration changes directly from the Policy Evaluation window. To evaluate a policy, follow these steps:

1. Expand the Object Explorer to Management  Policy Management  Policies. 2. Right-click on the Policies folder and choose Evaluate. A dialog similar to the one shown in Figure 16.15 appears.

Figure 16.15 The Evaluate Policies dialog

UNDERSTANDING POLICY-BASED MANAGEMENT

3. Choose the policies you want to evaluate and click the Evaluate button. In Figure 16.16, the Database Auto Shrink policy was evaluated. This policy was applied to four databases on the server, and one of them was in violation of the EncryptionDB policy.

Figure 16.16 The Evaluation Results dialog

4. To view the details of a policy violation, click the Details hyperlink for the record you would like to view. A dialog similar to the one shown in Figure 16.17 appears.

5. If you can configure the settings to conform to the policy, a checkbox will appear next to each row. If you choose the checkboxes, and click the Apply button, any settings that were violating the policy are configured to conform to it. In our situation, this would set the AutoShrink option to False for the EncryptionDB database.

Figure 16.17 The Policy Result details

|

493

494

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

EVALUATING POLICIES AGAINST MULTIPLE SERVERS You can evaluate a policy across many servers by using a Central Management Server. A Central Management Server stores connection information for multiple SQL Servers. Think of this as a centralized list of registered servers. All connections must use trusted authentication, so there aren’t any passwords stored in clear text. To use a Central Management Server, you will use the Registered Servers window in Management Studio. A Central Management Server stores connection information about SQL Servers in the msdb database of the Central Management Server. Figure 16.18 shows the Registered Servers window with a Central Management Server defined. If the Registered Servers window isn’t visible, you can turn it on by choosing View  Registered Servers.

Figure 16.18 Central Management Servers

You can create server groups using a Central Management Server and then evaluate a policy against an entire server group. The process for evaluating a policy against multiple servers is exactly the same as evaluating the policy against a single server. If a connection can’t be made to one of the servers in the group, the rest of the policy evaluation will continue on the available servers. You can also execute queries across all servers in a group by right-clicking on the group and choosing Query.

CREATING A NEW POLICY Creating a new policy is a fairly simple process. There are several ways that a policy can be created: •u฀ Online, with a connection to a server •u฀ Offline, without a connection to a server •u฀ Exporting the current state of a facet as policy

The processes for creating a policy online or offline are very similar. A policy that is developed offline is saved to an XML file and can later be imported into one or more SQL Servers for evaluation. To create a new policy in offline mode, choose File  New  Policy in SQL Server Management Studio. To create a new policy on a SQL Server, follow these steps:

1. Expand the Object Explorer to Management  Policy Management  Policies. 2. Right-click on the Policies folder and choose New Policy. The dialog shown in Figure 16.19 appears.

UNDERSTANDING POLICY-BASED MANAGEMENT

Figure 16.19 The Create New Policy dialog

3. Type a descriptive name for your policy. 4. Use the Check Condition dropdown list to create a new condition. The dialog shown in Figure 16.20 appears. If you’re choosing an existing condition, skip to step 8.

Figure 16.20 The New Condition dialog

|

495

496

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

5. Type a name for the check condition, and choose the appropriate facet for your policy. 6. Use the dropdown lists in the Expression Editor to create an expression that states the way a component should be configured. Our example says that each login should be a windows user or a windows group.

7. Choose the Description pane and enter a description for your condition. Click OK. 8. Choose the targets to which the policy should apply. You can create another condition to filter the targets to which any policy applies.

9. Choose your evaluation mode. Depending on the type of condition used, you may be given different options. This is because only certain facets and properties can be captured using triggers and event notifications.

10. Optionally, choose or create a server restriction. A server restriction is a condition that uses one of the server facets to limit where this policy should apply. For example, some settings only apply to a specific SQL Server version or edition.

11. Choose the Description page of the policy, select a category, type a description, and additional help text to display.

12. Click OK to create the policy. If you already have a component configured the way you would like to have used in a policy, you can export the current state of a facet as a policy. This is accomplished by viewing the appropriate facet of the object you would like to export, and clicking the Export Current State as Policy button. There are many objects that you can right-click on in the Object Explorer to view facets. The image in Figure 16.21 shows an example of a database configuration facet.

Figure 16.21 A database configuration facet

UNDERSTANDING POLICY-BASED MANAGEMENT

|

When you click on the Export Current State as Policy button, you are prompted to enter a name for the new policy and condition that will be created, as shown in Figure 16.22. You can also choose to store the policy on the local server or to an XML file.

Figure 16.22 The Export as Policy dialog

EVALUATING POLICIES ON A SCHEDULE All of the policies we’ve worked with so far have used the On Demand evaluation mode. This means that in order for the policy to be evaluated or applied, it must be manually evaluated by the database administrator. You can also evaluate a policy on a schedule. This is accomplished with a SQL Server Agent Job that uses a PowerShell script to evaluate the policy on a routine basis. The output of policy evaluation is stored in the msdb system database and can be displayed by SQL Server Management Studio. Using scheduled policy evaluations will allow you to view Policy Health States in the Object Explorer, so you can easily identify areas that aren’t configured according to policy. Figure 16.23 shows the Object Explorer with Policy Health States enabled. This can be toggled by the button at the top of Object Explorer.

Figure 16.23 Policy Health States enabled

497

498

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

The icons that contain red X’s next to the Object Explorer nodes represent a policy violation in either that component or some children of that component. In the example in Figure 16.23, the icon is displayed on the server Databases folder, and EncryptionDB database. You can right-click on any of these nodes, and choose Policies  View to view the policies that apply to the node and any violations, as shown in Figure 16.24.

Figure 16.24 The View Policies dialog

All policies can be executed on a schedule so long as their target is SQL Server 2008. A policy can be converted to execute on a schedule by changing its execution mode and specifying a schedule. If you change to a scheduled execution mode, you must remember to enable the policy in order for it to execute and be applied.

ENFORCING POLICIES—ON CHANGE, LOG Some policies can be enforced by either logging or preventing a change that would violate the policy. In order to use either of the On Change modes for policy evaluation, you must be working with a facet that is transactional, and one on which activity can be captured using either event notifications or DDL triggers. The event notifications or DDL triggers are automatically created and maintained by the policy-based management infrastructure. Policies that use the On Change: Log Only option won’t prevent changes that would violate policy, but it will log the policy violation, and it can be immediately viewed using the Policy Health State in Object Explorer, which was discussed in the last section. An example of a policy that uses On Change, Log Only could be a naming policy that requires all views be prefixed with V_. This policy can be created using the Multipart Name facet, and it uses the condition displayed in Figure 16.25. When the policy is violated, the changes are logged and displayed using the Policy Health State in Object Explorer, as shown in Figure 16.26.

UNDERSTANDING POLICY-BASED MANAGEMENT

|

Figure 16.25 The Views Prefixed with V_฀condition

Figure 16.26 The Object Explorer Policy Health for Views

ENFORCING POLICIES—ON CHANGE, PREVENT Policies can use an evaluation mode that will prevent changes that don’t comply with the policy. This mode can be used with a limited number of facets, because events must be able to be prevented and rolled back using DDL triggers. Because these types of policies can disrupt database operations, most of the time they should be placed into a separate category that doesn’t mandate database subscriptions. This will allow individual databases to subscribe to the appropriate policies. An example of using the On Change: Prevent evaluation mode is similar to the last example. We will require that all new stored procedures have names that are prefixed with usp_. The only difference between this example and the last one is that we will prevent changes that violate the policy when logging them.

499

500

| CHAPTER 16

USING THE RESOURCE GOVERNOR AND POLICY-BASED MANAGEMENT

It’s important to fill out description and help information for a policy that prevents changes. Any error messages that are shown will display the description of the policy, and any help text and URL. The dialog for configuring a policy’s category, description, and help text is shown in Figure 16.27.

Figure 16.27 The Policy Description page

If a stored procedure is created that doesn’t conform to the policy, the trigger will roll back the transaction and produce a message similar to the one shown here. Policy฀‘Stored฀procedures฀prefixed฀with฀USP_’฀has฀been฀violated฀by฀‘SQLSERVER:\SQL\ SQL08RC0\DEFAULT\Databases\AnotherDB\StoredProcedures\dbo.badProcName’. This฀transaction฀will฀be฀rolled฀back. Policy฀condition:฀‘@Name฀LIKE฀‘usp_%’’ Policy฀description:฀‘You฀must฀prefix฀all฀stored฀procedure฀names฀with฀usp_฀according฀ to฀policy.’ Additional฀help:฀‘Additional฀Help฀Text’฀:฀‘http://my.web.site/helptext’ Statement:฀‘CREATE฀PROC฀badProcName AS SELECT฀@@VERSION ‘. Msg฀3609,฀Level฀16,฀State฀1,฀Procedure฀sp_syspolicy_dispatch_event,฀Line฀65 The฀transaction฀ended฀in฀the฀trigger.฀The฀batch฀has฀been฀aborted.

THE BOTTOM LINE

The Bottom Line Use the Resource Governor to manage and balance varying workloads. The Resource Governor provides powerful capabilities for monitoring and tuning varying workloads on a SQL Server. Utilizing the Resource Governor can help you better understand and balance workloads across your SQL Server. Master It

What steps must you follow to configure and use the Resource Governor?

Tune the resource pool and workload group settings as required. Use policy-based management to define, evaluate, and enforce a desired configuration. Using policy-based management makes it much easier to configure a server according to best practices and defined policies. Master It In order to evaluate a policy against a previous version of SQL Server, how must the policy be configured?

|

501

Chapter 17

SQL Server and the .NET Client As a SQL Server administrator or developer, you do not care about the details of how to program data access to SQL Server. Unless you are also wearing the client developer hat, it just is not relevant. However, we think that it is very important for the SQL Server professional to be aware of what is happening on the client side. How is your SQL Server database accessed by client applications or a data access layer in a multi-tier application? An inquisitive database professional should know these things, because they might affect data security, integrity, or performance. Understand that our goal is not to provide complete coverage of data access technology. This book is about SQL Server, not data access programming. Therefore, you should not expect a great amount of detail about data access programming in this chapter. Our goal is to provide the SQL Server professional with the essential information necessary to talk effectively with .NET developers and to help you understand the impacts of the data access technology on the data server tier. As a database administrator or developer, you should read this chapter with that goal in mind. We want you to understand the effects data access technology will have on your world, but we are not trying to offer a complete discussion of client data access programming. In this chapter, you will learn to: •u฀ Connect and query a SQL Server database using ADO.NET connected and disconnected

techniques •u฀ Use prominent special features of ADO.NET and the SQL Native Client •u฀ Understand and implement simple examples using the new Language Integrated Query

(LINQ) environment •u฀ Understand and implement simple examples using the ADO.NET Entity Framework

Understanding ADO.NET Data access technology has been through a significant evolution over the last 15 years. In your early days of programming, you may have worked primarily with flat file databases or pseudorelational engines such as Clipper, Fox Pro, Dbase, or Access. Back in those days, cursor-based data access models were the norm and processing that data typically followed this sequence:

1. Open file. 2. Query data to generate cursor. 3. Process data through cursor. 4. Close file.

504

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

As database technology evolved and relational databases came to be more commonplace in the business world, data access technology should have evolved with it. Unfortunately, this was not the case. Mainstream data access technology continued to be cursor-based rather than setbased even though the data engines in common use were capable of greater efficiencies. In the Microsoft microcosm, this was especially apparent in the evolution of data access technologies such as the Microsoft Data Access Objects, Remote Data Objects, ODBC Direct, and Active Data Objects. None of these technologies effectively leveraged the set-based nature of the relational data engine that SQL Server provided.

A Cursor in a Set-Based World A database cursor is an artificial structure that represents underlying data through a set of pointers. Cursors allow data processing at the “row” level. By following each individual pointer to the underlying data, the client assesses and processes data values one at a time. This may seem a natural way to process data, but it is very inefficient in a relational data model. Instead, the client should process data in sets whenever possible. Set Theory is a branch of mathematics that describes objects as collections based on common factors. Dr. E. F. Codd, the pioneer in relational database theory, was heavily grounded in set-based mathematics. He, therefore, designed his relational database theory to work with sets. The theory is that defining the parameters of a set of data values, and then manipulating that set consistently, is much more efficient than manipulating values individually. Unfortunately, far too much database code ignores this inherent superiority of set-based techniques.

When Microsoft introduced the ADO.NET model, they significantly departed from their traditional cursor-based data access technologies of the past. For the first time in Microsoft history, users had the capability of working with sets. Although much of the processing on the client application was still row-based, at least we were able to utilize the set-based nature of the SQL Server data engine while still having the option of limited cursor support when necessary. ADO.NET supports two primary strategies for data access. •u฀ Connected access through cursors •u฀ Disconnected access through sets

Both of these techniques rely on some common elements, such as connections and commands, although they differ significantly in how the database returns data to the client. We will begin this discussion by looking at those common elements before discussing how those elements are used in each of our scenarios. Figure 17.1 provides a simplified illustration of the ADO.NET 3.5 object model. The figure is not complete; it only defines key elements of the model.

UNDERSTANDING ADO.NET

Figure 17.1

ADO.NET

The ADO.NET object model

Connected Operations

Client or Data Access Layer

|

SQL Data Reader

SQLCommand

Data Set

SQL Connection

SQL Data Adapter SQL Server

Disconnected Operations

Making the Connection Figure 17.1 shows that all communication to SQL Server happens through a SqlConnection object. Regardless of whether you are using a connected or disconnected strategy, you will need a connection to interact with the server. To make this connection, you will have to provide a connection string. Table 17.1 lists some of the common values included in a SQL Server connection string. Again, this is not an inclusive list, but rather is meant to be indicative of typical settings in common use.

Table 17.1

Connection String Values

Value

Default

Description

Connection Timeout

15

The time in seconds to wait for a successful connection before the attempt is terminated.

Data Source Server Address

N/A

The server name or network address of the target server of the connection.

Encrypt

‘false’

When set to true and a certificate is installed, this value indicates that all data should be transmitted using SSL encryption.

Initial Catalog Database

N/A

The name of the database.

Integrated Security Trusted_Connection

‘false’

When true, Windows authentication is used. When false, SQL Server Authentication is performed. Valid values are ‘true’, ‘false’, ‘yes’, ‘no’, and ‘sspi’ (equivalent to true).

MultipleActiveResultSets

‘false’

When true, multiple result sets can be maintained for a single connection. Supported since ADO.NET 2.0.

505

506

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

Table 17.1

Connection String Values (continued)

Value

Default

Description

Packet Size

8192

Size of the network packet used to communicate with SQL Server.

Password Pwd

N/A

Authentication password. Only used when Integrated Security is set to false.

User ID

N/A

Authentication ID used when Integrated Security is set to false.

Reading the Fine Print Because we want this chapter to offer a high-level discussion of data access technology, we need to make some significant assumptions before we can proceed. Please take a moment to read these assumptions and disclaimers. You must speak the language. This is not the time to discuss .NET or object-oriented programming concepts. In the interest of brevity, we will be using many of these terms without defining them first. In addition, because you can develop .NET applications in many languages, we had to standardize on one for illustration purposes. We chose to use the C# language. Do your homework. If you want to code and execute any of our examples, you may have to include additional code that we do not provide. For example, the SqlConnection class is in a .NET namespace called System.Data.SqlClient. If you coded the connection examples shown in the following text, you would have to either fully qualify the SqlConnection class using the namespace or provide a using statement in your code, removing the need to fully qualify the class name. We omitted these details from our code so that we can focus on our core issues. You will have to do your own research if you want to implement these techniques. Know the data access model. ADO.NET is the universal data access model for .NET applications. These applications can use a variety of data sources; SQL Server is one option but not the only option. Other data sources such as Oracle, ODBC, and OLE DB easily fit into the ADO.NET framework. However, this book focuses strictly on SQL Server 2008, so we will not address any of these other implementations. We will show you only models and code relating to SQL Server implementations.

The general format of the connection string is “keyword=value;[n…]”. In other words, name/ value pairs for each of the settings are separated with a semicolon. When you create a connection, the connection string is generally provided like this: SqlConnection฀cn฀=฀new฀SqlConnection(ConnectionString);

Alternatively, you can also assign a value to the ConnectionString property of the SqlConnection object subsequent to that object’s instantiation, as in this example: SqlConnection฀cn฀=฀new฀SqlConnection(); cn.ConnectionString฀=฀ConnectionString;

UNDERSTANDING ADO.NET

|

Using the former pattern, connecting to the default instance of a SQL Server on a machine named TestServer, using a database named TestDB, and connecting using integrated security would result in the following code: String฀sCon฀=฀“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true”; SqlConnection฀cn฀=฀new฀SqlConnection(sCon); cn.Open();

Once the connection is open, you can use that connection to interact with the SQL Server. Note that in our example, we have explicitly opened the connection to the server by using the Open method of the SqlConnection object. This is not always required. In some cases, other objects, such as a SqlDataAdapter, can open the connection for you. However, any time that you want to interact with SQL Server, there must be an open connection, whether you opened it explicitly in your code or implicitly by another object in the model. Remember that if you open something, you have to close it. When you open a connection explicitly, another object in the model will generally not implicitly close it. The notable exception to this rule is when you create an object and include an auto-close behavior in the initialization parameters.

Defining the Command The SqlCommand class represents the statement that the client submits to SQL Server for execution. In SQL Server, this command can represent a table name, a stored procedure call, or an ad hoc SQL statement. The client issues a command through an open connection, thereby providing instructions to SQL Server as to the results that it should return. The pattern for using SqlCommand is similar to the one used for SqlConnection. The most important parameter that you will provide is the CommandText. One option is to provide this value as a parameter in its constructor when you create the object, as with this example: String฀sSQL฀=฀“SELECT฀au_fname,฀au_lname฀from฀dbo.authors;”; SqlCommand฀cmd฀=฀new฀SqlCommand(sSQL);

You can also assign the value of the CommandText property after you create the object, as in this example. String฀sSQL฀=฀“SELECT฀au_fname,฀au_lname฀from฀dbo.authors;”; SqlCommand฀cmd฀=฀new฀SqlCommand(); cmd.CommandText฀=฀sSQL;

Commonly, you will also provide the connection information for your command at the same time, so that the command is aware of the connection to which it has been associated and through which it will execute. You can provide this connection information to the constructor as the object is instantiated, or alternatively by assigning a value to the Connection property of the SqlCommand object as illustrated in this example. (Please note that to compile the following code, you can use only one of the two options indicated, so comment one out if you are running the examples.) String฀sCon฀=฀“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true”; String฀sSQL฀=฀“SELECT฀au_fname,฀au_lname฀from฀dbo.authors;”;

507

508

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

SqlConnection฀cn฀=฀new฀SqlConnection(sCon); //฀Option฀1 SqlCommand฀cmd฀=฀new฀SqlCommand(sSQL,฀cn); //฀Option฀2 SqlCommand฀cmd฀=฀new฀SqlCommand(); cmd.CommandText฀=฀sSQL; cmd.Connection฀=฀cn;

You can also use a stored procedure for your command text value. Suppose that you have a stored procedure called GetOrdersByQuantity that accepts an integer value as a parameter— called @Quantity—that represents the total number of units ordered. The procedure will return the order data based on this parameter. Assuming that you have provided a parameter value of 10, you would use code like the following to configure this command. SqlCommand฀cmd฀=฀new฀SqlCommand(); cmd.CommandText฀=฀“GetOrdersByQuantity”; cmd.Parameters.AddWithValue(“@Quantity”,฀10);

The Database Effects of Inappropriate Client Code For the SQL Server DBA or developer, this syntax should pose some interesting questions. If the client developer can provide their own SQL code when querying the database, what are the effects of this practice? What other issues arise when developers take advantage of the freedoms that the ADO.NET syntax allows? The authors have had to deal with one or more of the following issues in virtually every SQL Server/ .NET implementation that we have addressed. Therefore, rather than presenting a single case study, we have chosen to aggregate aspects of many cases regarding this subject. A command can be an ad hoc SQL statement, a table name, or a stored procedure name. All these options have performance and security ramifications that we must address. Command Object Performance Issues The SqlCommand object allows the developer to provide a table name as CommandText. This is a bad practice because it will typically return much more data to the client than is necessary. Ad hoc SQL statements can also lead to performance problems because SQL Server does not provide the same degree of caching for ad hoc SQL as it does for stored procedures. Although SQL Server does have some ad hoc caching capabilities, this cache is generally short-lived. In most cases, you will get much better performance from your SQL Server by using stored procedures exclusively for all data access. Command Object Security Issues Allowing ad hoc SQL to access your applications has two general security problems: unnecessary permission exposure and SQL injection.

UNDERSTANDING ADO.NET

|

To execute ad hoc SQL code, a user must log in with an account that has the necessary permissions to perform the desired actions. This exposes the underlying database by permitting a user with valid permissions to access the database using alternative means, thereby circumventing the business rules of the application. Although you can avoid this somewhat by using application identities with secure passwords, this approach still poses a potential security threat. Another serious issue is the possibility of SQL injection. This occurs when an application takes string inputs directly from an end user and passes them to the SQL Server without first evaluating and verifying the inputs. Using this approach, an end user with some SQL knowledge can inject malicious code into the data engine through these inputs. Because the application treats all inputs as ad hoc SQL and executes them accordingly, this can be a very serious situation. You can solve both of these problems with stored procedures. The database administrator can assign permission to the users to execute the procedures without having to grant any permissions relating to the underlying schema objects. When properly parameterized, procedures are also much less susceptible to SQL injections because the inputs are not raw strings. The Solution In the real world, we see these situations all the time. The best practice is to use stored procedures exclusively. As a SQL Server DBA, you should not allow applications to use ad hoc SQL to access your databases. You should never grant table access permissions to nonadministrative accounts. While there may be times when you need to violate these rules to accomplish certain goals, you should consider stored procedures to be your standard and enforce that standard for all data access. Trust us on this one. Down the road, you will be glad you did.

Connected Operations Now that we have seen the basic implementation of the SqlConnection and SqlCommand objects, we are ready to apply this to data operations. We will begin with a discussion of connected operations. When we use the term “connected operations,” we refer to actions that require the client to maintain a connection to the server for the entire duration of the operation. A developer can use connected operations either to retrieve data from a database or to make modifications to the database. Retrieving data in a connected mode typically involves using the SqlDataReader object in conjunction with a SqlCommand object. Making data modifications in a connected mode does not require, or even allow, a SqlDataReader and SqlCommand object to perform the action directly.

CONNECTED RETRIEVAL USING THE SQLDATAREADER The SqlDataReader class is the last remaining ADO.NET holdover from the cursor-based data access models in Microsoft’s past. The SqlDataReader represents a read-only, forward-only cursor to SQL Server that a developer can use to retrieve and process data from SQL Server on a row-byrow basis. Because it is read only, you cannot use a data reader to make any data modifications. In addition, because it is forward only, you are only allowed to execute movement in the cursor

509

510

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

to the next row of data. There is no random access to the data, nor is there an ability to move backward or to the end of a set without advancing through the entire set one row at a time. To generate the SqlDataReader instance, you must use the ExecuteReader method of the SqlCommand object. This method executes the CommandText of the command through the configured connection associated with the command and generates a server-side cursor as a result. The SqlDataReader instance represents a reference to that cursor, allowing the developer to move through the data using the data reader’s Read method. Listing 17.1 provides an example of using a data reader. The purpose of this code is to execute a stored procedure that provides a list of orders to the client, which the client then displays in a console window.

Listing 17.1

Implementing a SQLDataReader

using฀System.Data.SqlClient; using฀System.Data; public฀void฀ProcessSampleReader() { ฀฀฀//฀Declare฀all฀variables ฀฀฀SqlConnection฀cn; ฀฀฀SqlCommand฀cmd; ฀฀฀SqlDataReader฀rd; ฀฀฀//฀Connect฀and฀generate฀reader ฀฀฀cn฀=฀new฀SqlConnection ฀฀฀฀(“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true”); ฀฀฀cmd฀=฀new฀SqlCommand(“GetOrdersByQuantity”,฀cn); ฀฀฀cmd.Parameters.AddWithValue(“@Quantity”,฀10); ฀฀฀cn.Open(); ฀฀฀rd฀=฀cmd.ExecuteReader(CommandBehavior.CloseConnection); ฀฀฀//฀Process฀and฀close฀the฀reader ฀฀฀while฀(rd.Read()) ฀฀฀{ ฀฀฀฀฀฀Console.WriteLine(rd[“OrderNumber”].ToString()); ฀฀฀} ฀฀฀rd.Close(); }

A few elements of this code listing warrant additional explanation. First, please notice that we deliberately open our connection to SQL Server before executing the ExecuteReader method of cmd. This is required. You cannot execute a reader unless the associated connection is open. However, you may have noticed that we never explicitly close that connection. The connection is implicitly closed when we close the reader object on the last line. This is because of the argument that we provided to the ExecuteReader method, called CommandBehavior.CloseConnection. This argument tells the reader to close the connection when the reader is closed.

UNDERSTANDING ADO.NET

|

As a database administrator, you need to ensure that your client developers are closing their connections when they are finished with them. This should be a best practice enforced throughout the organization. Without this close behavior, the application will not promptly release the connection back to the connection pool. This may cause the pool size to grow over time to its maximum allowable size. Eventually, performance will start to drag because of the insufficient number of available connections in the pool. You should also note that the value of the parameter uses an int data type. Inside the stored procedure, the procedure uses the integer in its SQL queries for comparison purposes. The procedure expects an integer (int), not a string. Because the parameter is not a string that SQL Server can parse and execute, we have limited our exposure to SQL injection. You should enforce this practice whenever possible. One problem area that you might run into when client developers use data readers is the overhead of creating and maintaining the cursor. If the client uses the data just once, such as to load a list box, using a data reader makes sense. However, if the client must consult the data frequently, such as with a lookup table, you should consider using a DataSet to cache the data so that you do not have to repeat the retrieval more often than necessary.

CONNECTED MODIFICATIONS USING THE SQLCOMMAND Using SqlCommand, you can also execute queries and stored procedure calls against the server for which you do not expect any return data. This is typical of insert, update, and delete queries. To execute these types of queries, you will not need a data reader—just a connection and a command. The pattern is very similar to the one previously discussed, the primary difference being that you will use the ExecuteNonQuery method of the command object. Again, although the CommandText can be an ad hoc SQL statement or a stored procedure, using a procedure is strongly recommended. Listing 17.2 illustrates this process. Suppose that you have a stored procedure that updates an order’s quantity based on the order number. The stored procedure is called UpdateQuantityByID and has two parameters: @ID, which represents the order ID of the targeted order, and @NewQuantity, which represents the new value that you will provide for the order quantity. Assuming that the ID of the order you want to modify is 123 and the new quantity you want to assign is 20, the procedure call might look like the one in Listing 17.2.

Listing 17.2

Modifying Data Using a Connected SqlCommand

using฀System.Data.SqlClient; public฀void฀ExecuteUpdateQuantity() { ฀฀฀//฀Declare฀Variables ฀฀฀SqlConnection฀cn; ฀฀฀SqlCommand฀cmd; ฀฀฀//฀Connect฀and฀execute฀the฀data฀modification ฀฀฀cn฀=฀new฀SqlConnection ฀฀฀฀(“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true”); ฀฀฀cmd฀=฀new฀SqlCommand(“UpdateQuantityByID”,฀cn);

511

512

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

฀฀฀cmd.Parameters.AddWithValue(“@ID”,฀123); ฀฀฀cmd.Parameters.AddWithValue(“@NewQuantity”,฀20); ฀฀฀cn.Open(); ฀฀฀cmd.ExecuteNonQuery(); ฀฀฀cn.Close(); }

The example shows one of the most efficient ways to execute a data modification from the client. Although you are maintaining the connection throughout the update, you are holding that connection for the shortest possible time. As long as you use a well-written stored procedure, this will provide the best possible solution to this situation. It is also possible to modify data through a data cache called a DataSet and merge those changes back into the database later. However, this is not an optimal technique from a performance perspective and you should avoid it when possible. Instead, rely on good stored procedures to provide the necessary set-based logic to make the required modifications.

Disconnected Operations The heart of ADO.NET is its support for disconnected operations. Now that it has the ability to retrieve sets of data from the server and cache those on the client for further processing, ADO.NET is stepping closer in every release to the ideal of a client data processing solution. With the introduction of a technology called LINQ to DataSet, which we will discuss later in the chapter, we now have the ability to query cached DataSets instead of having to examine them using collections. Remember that when we refer to disconnected operations, we are not suggesting that the client does not need to connect, but rather that the client does not have to maintain the connection while processing the retrieved data. The advantage is that the connection time can be as short as possible, thereby reducing the likelihood of server problems such as blocking and deadlocking. There are two additional classes to consider in our discussion of disconnected operations. They are the SqlDataAdapter class and the DataSet class. You will use these classes in conjunction with the SqlConnection and SqlCommand to query the data and return it to the client as a cached set (rather than a live cursor).

Have You Noticed the Pattern? Most of the ADO.NET classes that we have discussed so far have names that begin with the prefix “Sql.” When a class name starts with this prefix, you know that the class is specific to the SQL Server implementation of ADO.NET. We use SqlConnection to connect only to SQL Server databases. The SqlCommand class only queries SQL Server databases. All of the other classes fit the same pattern. Other data platforms, such as ODBCConnection and OracleConnection, have classes that also follow this pattern. So what should we conclude about the DataSet class? We can infer that because this class does not have a data platform-specific prefix, this class is in fact not specific to any data platform. In fact, this is the case. The DataSet class is defined in the System.Data namespace. This distinguishes it from the other SQL Server-specific classes, which are defined in the System.Data.SqlClient namespace. DataSets are universal data caches. No matter where the application acquired the data from, it can still be stored in a DataSet.

UNDERSTANDING ADO.NET

|

Because the client disconnects from the server after retrieving the data, the manipulation of the DataSet has no performance implications on the server. Therefore, we will not concern ourselves with how to process the data once the application retrieves it. However, we should look at how the application executes the procedures and returns the data to the client. The process of loading a DataSet from a SQLServer data source requires a SqlDataAdapter instance. The SqlDataAdapter class uses the standard adapter design pattern as a go-between that connects the DataSet to the SQL Server data source. Because the physical storage structure of SQL Server differs substantially from both the Tabular Data Stream and the storage architecture of the DataSet, a translation must occur if the data stream from SQL Server is to be converted to the storage format required by the DataSet. The SqlDataAdapter performs this translation. The critical method of the SqlDataAdapter is the Fill method. This method executes a command object associated with the select behavior of the adapter and translates the resulting data stream for the DataSet, thus filling the DataSet with data. It is possible for a DataSet instance to contain multiple tables of data, and you can even relate these tables to each other using DataRelation objects, which are similar to foreign keys. It is, therefore, possible for a single DataSet to contain many logical tables, providing a very effective data cache format. Listing 17.3 provides an example of loading a DataSet using the SqlClient classes.

Listing 17.3

Populating a DataSet

using฀System.Data; using฀System.Data.SqlClient;฀ private฀DataSet฀GetOrdersDataSet() { ฀฀฀//฀Declare฀all฀variables ฀฀฀SqlConnection฀cn; ฀฀฀SqlCommand฀cmd; ฀฀฀SqlDataAdapter฀ad; ฀฀฀DataSet฀ds; ฀฀฀//฀Configure฀connection฀and฀command ฀฀฀cn฀=฀new฀SqlConnection ฀฀฀฀(“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true”); ฀฀฀cmd฀=฀new฀SqlCommand(“GetOrdersByQuantity”,฀cn); ฀฀฀cmd.Parameters.AddWithValue(“@Quantity”,฀10); ฀฀฀//฀Configure฀adapter฀and฀load฀dataset ฀฀฀ad฀=฀new฀SqlDataAdapter(cmd); ฀฀฀ds฀=฀new฀DataSet(“SampleDS”); ฀฀฀ad.Fill(ds,฀“Orders”); ฀฀฀//฀Return฀DataSet ฀฀฀return฀ds;฀฀฀฀ }

513

514

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

While a number of different code patterns will work for this task, this listing demonstrates a typical implementation of this process. Notice how the code first configures the command before handing it off to the adapter. Although the adapter can also handle other tasks, such as merging data inserts, updates, and deletes into the source database, the select process is by far the most common. The Fill method also allows us to name the DataTable object that is contained in the DataSet. In this case, we have named the DataTable Orders. The server-side benefit of using DataSets is that in some cases you only have to query the database once; the client can then use the DataSet as needed without having to requery the database. This works fine as long as some data latency is acceptable to the client. The data begins to age as soon as the server returns it to the client, and because the client does not have an active connection to the server, it cannot automatically detect when another application modifies the data on the server.

Detecting Changing Data Although the client does not maintain a connection to the server, the client can still detect changing data in other ways. The two primary approaches use rowversion data types and SQL Notifications, respectively. The more traditional approach is to use rowversion types to determine if the underlying data has changed. This approach has been around for a very long time. (In fact, the old DBLibrary API, which started out as the proprietary API SQL Server supported in the 4.2 generation, contained a statement called Browse that required rowversion types on every table.) Today, the rowversion process works like this: Because the server automatically updates rowversion columns whenever it modifies data for a row, you can always compare a current rowversion฀ value with a cached rowversion value. When the client retrieves data, it also caches the rowversion so that if an update must take place, the procedure that performs the update will accept the rowversion as a parameter. The server will make the update only where the rowversions are equal. If they are not equal, zero rows will be affected by the update. The client can detect this situation and then determine how to handle the scenario based in its business rules. The other option, SQL Notifications, is much newer. We will discuss this approach later in this chapter; however, the basic concept is that you will rely on the server to make callbacks to the client when data changes. These callbacks fire events on the client that it uses to respond to the fact that the data changed.

DataSets are not the only vehicle for data caching. Other alternatives are available. One popular option is to retrieve data using a reader that loads that data into collections. You can then use these collections for data binding, lookups, passing to other tiers, and so forth. As a SQL Server professional, you shouldn’t care which approach the client developer takes as long as they minimize the number of calls to the database and use caching effectively.

SPECIAL OPERATIONS IN ADO.NET

|

Special Operations in ADO.NET You cannot design a feature into an application if you are not aware that the feature exists. A data or enterprise architect is required by the nature of the job to be well versed in the features of the languages and tools that they use. With every new release of ADO.NET, Microsoft introduces more of these extra features, which are meant to provide grater flexibility in the data tier. While a discussion of the specifics of coding for these features is better suited for a book on ADO.NET than a book on SQL Server, it is still important for the database architect to know what options are available and how they impact performance and security on the server. In this section, we will discuss some of the more prominent features and their implications.

Multiple Active Result Sets (MARS) There is a restriction when working with client-generated cursors. Client developers accept it, but constantly complain about it. You can open only one cursor at a time through a single connection. If you want to open another cursor, you must open another connection, even if the connection parameters are exactly the same as those for the first connection. The underlying logic that causes this behavior is a deliberate restriction in the API that only allows a single pending request for an operation. This is meant to preserve data integrity. While this is desirable in most cases, there are situations where this behavior is not necessary. For these special situations, we can now use Multiple Active Result Sets (MARS). The application’s responsiveness provides an alternative to other approaches such as maintaining multiple connections and using server cursors to simulate multiple concurrent requests. MARS works by interleaving some specific types of requests, thus allowing multiple requests to execute on a single connection without queuing. MARS does not allow all operations to interleave before the completion of their execution. There are restrictions. Only the following operations can interleave in a MARS session. •u฀ SELECT •u฀ FETCH •u฀ READTEXT •u฀ RECEIVE (with XACT_ABORT ON) •u฀ BULK฀INSERT (with XACT_ABORT ON) •u฀ Asynchronous cursor population

Within this list, there are other limitations. Because READTEXT is deprecated in the next release, we can scratch that one off the list. RECEIVE is specific to Service Broker behavior, which we will discuss in detail in Chapter 20, “Service Oriented Architecture and the Service Broker.” (In addition, because ADO.NET handles MARS entirely through the client, this behavior is not limited to SQL Server.) It is also important to consider what MARS does not do (or does not do so well). MARS does not provide for parallel processing of multiple operations. Because the operations are interleaving on the same connection, they are multitasking on that same connection. For example, if you have two processors, they can each execute a query on separate connections. Setting processor affinity on the server will determine the total number of processors that can execute SQL Server code.

515

516

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

Parallel This and That There is a common confusion between the concepts of processor affinity and Maximum Degrees of Parallelism (MaxDOP). Processor affinity refers to the binding of processors in a server to SQL Server execution. This allows SQL Server to ensure that it can execute without starving any other services. MaxDOP is a different creature altogether. The MaxDOP setting specifies how many parallel execution plans SQL Server can use to execute a single query. A very complex query might be broken up into multiple execution processes. These processes can execute in parallel if adequate resources are available. The result is a more complete utilization of processor resources and better performance when executing complex queries. No good thing comes without a cost. Although it sounds good on paper, the real cost of the MaxDOP option is its potential to deadlock multiple parallel plans. You might want to experiment with this option; however, if you notice errors stating that you have deadlocks with intra-query parallelism. The best solution is to set the MaxDOP option to 1, thus preventing query parallelism and the problems that can come with it.

Enabling MARS is a simple process. Because the client API handles everything, no server configuration is necessary to enable this behavior. Simply add an option to the connection string for multiple active result sets, and the client will automatically interleave any statements that it can through this connection. A connection string configured to support MARS would look like this: String฀sCon฀=฀ ฀฀฀฀“Data฀Source=TestServer;Database=TestDB;Integrated฀Security=true;MultipleActiv eResultSets=true”; SqlConnection฀cn฀=฀new฀SqlConnection(sCon);

Interleaving requests through MARS can benefit the server by not requiring as many connections to perform multiple operations. It can also be extremely convenient for the client-side developer. However, MARS is more prone to deadlocking and can cause additional blocking on the server. You should only use it in situations where you can verify that the benefits of MARS outweigh the potential hazards.

Using SQLBulkCopy In the early days of SQL Server, we used a command-line utility called the bulk copy program to bulk load data from one location to another. The strength of the bulk copy program was in its flexibility. All you needed was a text file. A text file extracted from any source could be bulk loaded into SQL Server, just as SQL Server could output its data into a text file through the same command line. The problem with the bulk copy program was that it was tedious to use, especially from within a client application. Although Transact-SQL supported a BULK฀INSERT operation, what was needed was a client class that could do bulk loading of data with the same efficiencies as the bulk copy program. The SQLBulkCopy class fits this requirement and is very easy to implement. You have full control over the source and destination, including column mapping, batch size, and connection properties. If the client goal is to migrate large amounts of data from one SQL Server to another, the SQLBulkCopy class should be the option of first preference.

SPECIAL OPERATIONS IN ADO.NET

The class is easy to use. You must define the connection and query that you will use for data extraction, the connection and table destination along with column mappings if necessary, and any other additional information such as a batch size. Then simply execute the operation. Listing 17.4 provides an example of the SQLBulkCopy program in action. Note that this code assumes that the destination table is already present upon execution of the operation. You can use this script to create the table if needed. USE฀SandboxDB; CREATE฀TABLE฀BulkCopyTarget( ฀฀฀Title฀nvarchar(8)฀NULL, ฀฀฀FirstName฀nvarchar(50)฀NOT฀NULL, ฀฀฀LastName฀nvarchar(50)฀NOT฀NULL ฀฀฀); GO

Listing 17.4

Using the SQLBulkCopy Class

using฀System.Data; using฀System.Data.SqlClient; using฀System.Windows.Forms; private฀void฀ProcessBulkInsert() { ฀฀฀//฀Declare฀variables ฀฀฀SqlConnection฀cnSource; ฀฀฀SqlConnection฀cnDestination; ฀฀฀SqlCommand฀cmdExtract; ฀฀฀SqlCommand฀cmdCount; ฀฀฀SqlDataReader฀rdSourceReader; ฀฀฀SqlBulkCopy฀sbcPerson; ฀฀฀String฀sConSource฀=฀ ฀฀฀฀“Data฀Source=(local)\\MasteringSQL;Database=AdventureWorks2008;Integrated฀ Security=true”; ฀฀฀String฀sConDest฀=฀ ฀฀฀฀“Data฀Source=(local)\\MasteringSQL;Database=SandBoxDB;Integrated฀ Security=true”; ฀฀฀String฀sCmdExtract฀=฀“SELECT฀Title,฀FirstName,฀LastName฀FROM฀Person.Person;”; ฀฀฀String฀sCmdCount฀=฀“SELECT฀COUNT(*)฀FROM฀dbo.BulkCopyTarget;”; ฀฀฀Object฀sReturnCount; ฀฀฀//฀Display฀the฀count฀of฀records฀in฀the฀target฀table฀before฀the฀insert ฀฀฀cnDestination฀=฀new฀SqlConnection(sConDest); ฀฀฀cmdCount฀=฀new฀SqlCommand(sCmdCount,฀cnDestination); ฀฀฀cnDestination.Open(); ฀฀฀sReturnCount฀=฀cmdCount.ExecuteScalar(); ฀฀฀MessageBox.Show(sReturnCount.ToString());

|

517

518

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

฀฀฀//฀Extract฀the฀data฀from฀the฀source ฀฀฀cnSource฀=฀new฀SqlConnection(sConSource); ฀฀฀cmdExtract฀=฀new฀SqlCommand(sCmdExtract,฀cnSource); ฀฀฀cnSource.Open(); ฀฀฀rdSourceReader฀=฀cmdExtract.ExecuteReader(CommandBehavior.CloseConnection); ฀฀฀//฀Setup฀and฀perform฀bulk฀insert ฀฀฀sbcPerson฀=฀new฀SqlBulkCopy(cnDestination); ฀฀฀sbcPerson.BatchSize฀=฀100; ฀฀฀sbcPerson.DestinationTableName฀=฀“BulkCopyTarget”; ฀฀฀try ฀฀฀{ ฀฀฀฀฀฀sbcPerson.WriteToServer(rdSourceReader); ฀฀฀} ฀฀฀catch฀(Exception฀ex) ฀฀฀{ ฀฀฀฀฀฀MessageBox.Show(“Error฀writing฀rows฀\n฀“฀+฀ex.Message); ฀฀฀} ฀฀฀finally ฀฀฀{ ฀฀฀฀฀฀rdSourceReader.Close(); ฀฀฀} ฀฀฀//฀Display฀the฀count฀of฀records฀in฀the฀target฀table฀after฀the฀insert ฀฀฀sReturnCount฀=฀cmdCount.ExecuteScalar(); ฀฀฀MessageBox.Show(sReturnCount.ToString()); ฀฀฀cnDestination.Close(); }

SQL Query Notifications As we mentioned previously, latency is a common issue when working in a disconnected environment. Without an active connection, there is simply no way to identify directly if another application has changed data since your application retrieved that data from the server. SQL Server 2008 allows ADO.NET Windows applications to send a command to SQL Server and request that a notification be generated if executing the same SQL command would produce result sets different from those initially retrieved. This notification works as a call back to the client application. The infrastructure that supports this behavior is the SQL Server Service Broker. We will discuss Service Broker in more detail in Chapter 20; this is just a quick preview now of what it has to offer. Because setting this up is a multistep process, we will walk you through that process and then discuss the effects of query notifications when we are finished. The first step is to enable the Service Broker. You can control this database-level option in two different ways. You can set the option through Transact-SQL code by using the command ALTER฀DATABASE฀SandBoxDB฀SET฀ENABLE_BROKER฀and substituting the name of your database for SandBoxDB. You can also use the SQL Server Management Studio interface and change the setting through the Database Properties window, as pictured in Figure 17.2.

SPECIAL OPERATIONS IN ADO.NET

|

Figure 17.2 Enabling the Service Broker

Next, you must ensure that the user requesting the notifications has the permissions to receive those notifications. Users who execute commands requesting notification must have Subscribe Query Notifications database permission on the server. Client-side code that runs in a partial trust situation requires the SqlClientPermission. Now it is time to code. If you coded the previous example using the SQLBulkCopy class, you can use this to trigger changes to the underlying table. To make sure that you are starting fresh, you may want to truncate the BulkCopyTarget table before you continue. Our sample application will be a Windows application. You will need two CommandButton instances, one Label and one DataGridView on your startup form. You can lay these out any way you like. One button will execute the code to do the bulk load, while the other will set up the query notification. If you are not familiar with how to set up and code for a Windows interface in C#, don’t worry about it. Just read through the code. That is the most important part. We will begin by declaring the variables so that they are visible to the entire form. We will use these declarations. delegate฀void฀UIDelegate(); SqlConnection฀cnNotification; SqlCommand฀cmdNotification; DataSet฀dsNotification; String฀sCon฀=฀ ฀฀฀฀“Data฀Source=(local)\\MasteringSQL;Integrated฀Security=true;Database=SandBoxDB ;”; String฀sSql฀=฀ ฀฀฀฀“SELECT฀*฀FROM฀dbo.BulkCopyTarget฀“฀+ ฀฀฀฀“WHERE฀LastName฀=’Anderson’฀and฀FirstName=’Nancy’”;

519

520

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

For this example, we will assume that the code for the first button will handle the bulk load, so you can take that code from Listing 17.4. We will use the second button to set up the query notification. That code will look like this: private฀void฀button2_Click(object฀sender,฀EventArgs฀e) { ฀฀฀SqlDependency.Stop(sCon); ฀฀฀SqlDependency.Start(sCon); ฀฀฀if฀(cnNotification฀==฀null) ฀฀฀฀฀฀cnNotification฀=฀new฀SqlConnection(sCon); ฀฀฀if฀(cmdNotification฀==฀null) ฀฀฀฀฀฀cmdNotification฀=฀new฀SqlCommand(sSql,฀cnNotification); ฀฀฀if฀(dsNotification฀==฀null) ฀฀฀฀฀฀dsNotification฀=฀new฀DataSet(); ฀฀฀GetSandBoxData(); }

This code begins by clearing out any existing dependency and then setting up a new one. This will prevent you from accidentally subscribing to multiple dependencies. Notice that the dependency is based on the connection string. Because the SqlCommand object uses that connection data to execute its queries, any changes to the data that would affect this command will be valid for notification. At the bottom of this snippet is a call to GetSandBoxData. It looks like this: public฀void฀GetSandBoxData() { ฀฀//฀Clear฀out฀the฀DataSet ฀฀dsNotification.Clear(); ฀฀//฀Ensure฀the฀command฀object฀does฀not฀have฀a฀notification฀object. ฀฀cmdNotification.Notification฀=฀null; ฀฀//฀Bind฀the฀SqlDependency฀object฀to฀the฀command฀object. ฀฀SqlDependency฀dependency฀=฀new฀SqlDependency(cmdNotification); ฀฀dependency.OnChange฀+=฀new฀OnChangeEventHandler(dependency_OnChange); ฀฀//฀Populate฀the฀DataSet ฀฀using฀(SqlDataAdapter฀adapter฀=฀new฀SqlDataAdapter(cmdNotification)) ฀฀{ ฀฀฀฀adapter.Fill(dsNotification,฀“People”); ฀฀฀฀dataGridView1.DataSource฀=฀dsNotification; ฀฀฀฀dataGridView1.DataMember฀=฀“People”; ฀฀} }

The OnChangeEventHandler procedure is an event callback. When the data modification takes place on the server, the Service Broker will send a notification message to the client, which then raises the event on the client side.

SPECIAL OPERATIONS IN ADO.NET

|

The event handler looks like this. private฀void฀dependency_OnChange(object฀sender,฀SqlNotificationEventArgs฀e) { ฀฀UIDelegate฀uidel฀=฀new฀UIDelegate(RefreshData); ฀฀this.Invoke(uidel,฀null); ฀฀//Remove฀the฀handler฀as฀it฀is฀used฀for฀a฀single฀notification. ฀฀SqlDependency฀dependency฀=฀(SqlDependency)sender; ฀฀dependency.OnChange฀-=฀dependency_OnChange; }

The callback method uses a delegate (a function pointer) to refresh the grid when a client raises the event. The callback cannot refresh the grid directly, because there is a limitation in Windows applications that do not allow a callback event to interact directly with the UI. This is because the callback event is not executing on the UI thread. So what happens when the delegate calls the RefreshData method? That code looks like this. private฀void฀RefreshData() { ฀฀//฀Since฀the฀code฀is฀executing฀on฀the฀UI฀thread,it฀is฀safe฀to฀update฀the฀UI. ฀฀label1.Text฀=฀“Data฀Modified฀and฀Grid฀Updated”; ฀฀//฀Reload฀the฀dataset฀that฀is฀bound฀to฀the฀grid. ฀฀GetSandBoxData(); }

This may seem complex when you look at the code, but the concept is quite simple. This is a publisher/subscriber model where the SQL Server Service Broker is the publisher and the client application is the subscriber. By registering a SQLDependency object to the command, the client is subscribing to any notifications indicating that data within the bounds of the command have changed. In this example, the following events will occur.

1. Click button 2. The grid will appear, but it will be empty. 2. Click button 1 to execute the bulk load process, which will modify the underlying data. 3. The server fires the notification. 4. The client event handler executes. 5. This handler then refreshes the grid by clearing the DataSet and reloading it with the new data.

6. This updates the data in the grid. For the database administrator, what are the effects of query notifications? First of all, this is only a SQL Server-supported feature. It requires a client software layer called the SQL Native Client. This client provides the address for the callback.

521

522

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

This also requires that you enable the Service Broker for the database that you want to watch. While the overhead is not outrageous, it does all add up. The notification is handled by creating a Service Broker queue on the server for this notification. Each notification queue provides only a single notification. After the server sends the notification to the server, it removes the queue and the client must request the same notification again if it wants to continue the process. When it is used appropriately, this technique can provide a real benefit to the disconnected application. It works best when the underlying data modifications are infrequent but the client must respond immediately upon change and cannot wait—for example, for a polling interval to elapse before the client action takes place. If you plan to design query notifications into your applications, we recommend that you perform some stress testing on the system with a production level of notifications, especially if you have many clients and many applications all requesting notifications. This should help you to assess the performance implications specific to your application environment.

Introducing Language Integrated Query (LINQ) If this is your first look at Language Integrated Query (LINQ), you are in for a surprise. LINQ represents a quantum shift in the way we approach data access in client applications and data access layers. LINQ is clear evidence of the morphing boundaries between data stores, data caches, and, most importantly, the languages and technologies we use to access each layer. For example, consider this code. //฀Create฀and฀load฀generic฀list List฀beatles฀=฀new฀List(4); beatles.Add(“John”); beatles.Add(“Paul”); beatles.Add(“George”); beatles.Add(“Ringo”); //฀Execute฀LINQ฀query฀on฀list var฀favoriteBeatles฀=฀ ฀ ฀ from฀b฀in฀beatles ฀ ฀ where฀b.StartsWith(“P”) ฀ ฀ select฀b; //฀Iterate฀through฀results฀of฀LINQ฀query foreach฀(var฀b฀in฀favoriteBeatles) ฀ ฀ MessageBox.Show(b);

If you are a developer, this code is very exciting because it blurs the line between programmatic data structures and databases. If you are a database administrator, this can be a little unsettling—for exactly the same reason . We need to re-evaluate the concept of a queryable data structure in the context of LINQ. Traditionally, the database developer would view a queryable data source from the context of the data engine. SQL code provides the instructions that the data engine uses to perform the data operation. While modular data service design can provide interchangeability between data engines and data stores, these two components are companions that are never separated.

INTRODUCING LANGUAGE INTEGRATED QUERY (LINQ)

|

In this example, where is the data engine and what is the data store? Let’s take a look. This code begins by creating a data store from a generic List collection class. Previously, extracting data from this list would require iterations, comparisons, or searches. With LINQ, we have the elegance of being able to use SQL-like query logic instead. As its name implies, .NET programming languages such as C# and VB.NET integrate LINQ directly through the .NET Framework. This means that LINQ can use an existing API rather than requiring new ones. Let’s look at our sample code snippet again. Notice that the WHERE clause in this query uses standard string methods to provide a criterion for the query. Transact-SQL does not have a “StartsWith“ function. We could accomplish the same task through other means, but the client developer does not need to know that. They can continue to use the methods and API with which they are familiar. In other words, LINQ is integrated into the existing API to minimize the learning curve for the client developer. We could rattle on and on about how cool this is for developers, but since our audience here is SQL professionals, it would not be relevant. Our primary concern in this chapter is how LINQ affects SQL Server, so in this section we will start by introducing you to the different forms that a LINQ query can take in an application. Next, we will look specifically at LINQ to SQL functionality, and finally we will assess the impact that LINQ can have on SQL Server performance, security, and coding practice.

Different Flavors of LINQ The intention of LINQ is to be universal; it is a single query structure that you can use in applications to query data from a variety of data sources and structures. To accomplish this, LINQ appears in a variety of different flavors. The primary flavors of LINQ are •u฀ LINQ to SQL •u฀ LINQ to XML •u฀ LINQ to objects •u฀ LINQ to DataSet •u฀ LINQ to Entities

Some of these forms of LINQ are not relevant to SQL Server. Link to XML, which lets you query an XML document without the complexity of XQuery or requiring Document Object Model (DOM) code, is a very cool concept. Client and data access layer (DAL) developers love it, but it is not relevant to SQL Server. The only way that SQL Server might get involved in this scenario is to produce the XML that LINQ is querying. We could say the same about LINQ to objects. You might execute SQL queries for extracting data to populate into objects. In our previous example, we could have loaded the generic List instance with the data retrieved from SQL Server using a SqlDataReader instance. However, once you have retrieved the data and brought it back to the application or DAL, SQL Server no longer plays a role. Using the same logic, LINQ to DataSet would also not affect SQL Server beyond the process of originally populating the DataSet. Once the application populates the DataSet from the data source, it disconnects and no longer affects the server unless it attempts to reconnect and merge its changes back into the data source.

523

524

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

It seems that the two flavors of LINQ that will most affect SQL Server are LINQ to SQL, formerly known as DLinq, and LINQ to Entities, which is governed by the ADO.NET Entity Framework. We will discuss the entity framework in a later section of this chapter.

LINQ to SQL LINQ to SQL is nothing more than a basic Object-Relational Mapping (ORM) layer. We must place an emphasis on “basic.” It is not intended to be a full-scale ORM layer. The purpose is to create an object layer that represents data structures in SQL Server so that you can manipulate the data by manipulating the objects. LINQ provides the language for this manipulation as well as the infrastructure that manages this object to data relationship. Because of the nature of LINQ to SQL as an ORM layer, LINQ places certain restrictions on LINQ to SQL. (These restrictions don’t appear in other flavors of LINQ.)

Important Notice About Compatibility The release of Visual Studio 2008 significantly preceded the release of SQL Server 2008. As a result, Visual Studio 2008 is not compatible with SQL Server 2008 with respect to many features, such as creating data connection objects or database projects. You, therefore, have two options. First, you can use SQL Server 2005 for all of the following examples. Everything that we do in this chapter should work fine on SQL Server 2005, but you will have to translate a little here and there. Second, you can download the required compatibility patch from Microsoft. This will most likely be included in a Visual Studio 2008 service pack after the final release of SQL Server 2008, but until that time, you will have to download and install the necessary hotfix to provide compatibility. Search at http://www.microsoft.com/downloads for the text “Visual Studio 2008 Support for SQL Server 2008” to find the right fix for the build of SQL Server 2008 that you are using.

LINQ to SQL only works with SQL Server. You can use any version of SQL Server, including SQL Express, but LINQ to SQL Server does not work with other relational databases such as Oracle. LINQ to SQL depends on the SQL Server provider to provide the necessary support for this technology. If you want to use LINQ with other databases, you will have to look at the other LINQ flavors to provide the required interface. LINQ to SQL is tightly coupled. LINQ to SQL requires that you generate an Entity to Object mapping layer. LINQ tightly couples this layer to the database, so any schema changes to the database will require you to regenerate the entity layer. If the changes are significant, you might also have to modify existing code that depends on the entities that you modified.

Downloading the Northwind Database The examples that we will use of LINQ to SQL require that you install the Northwind sample database provided by Microsoft. You should be able to find this download at http://www.microsoft.com/ downloads. Search for “Northwind and pubs Sample Databases for SQL Server 2000.” Even though the databases are intended for SQL Server 2000, they will install just fine in SQL Server 2008. You will be downloading an .msi file. Executing the .msi will create a folder with the installation scripts. Run the instnwind.sql script on your SQL 2008 instance to create the Northwind database.

INTRODUCING LANGUAGE INTEGRATED QUERY (LINQ)

|

CREATING THE OBJECT RELATIONAL MAPPING LAYER The first step in LINQ to SQL is creating the entity classes that represent the Object Relational mapping layer. You can do this in the Visual Studio 2008 Object Relational Designer. The Designer application saves its data to a database mapping layer (.dbml) file, which is an XML file. Follow these steps to create the .dbml file for the Northwind database.

1. Open Visual Studio 2008 and select File New Project form the menu. Create a new Windows Forms application using the Visual C# language. Name the project LINQ_ Samples and store it in a location of your choosing.

2. To add the .dbml file to your project, select Project  Add New Item from the menu. Select LINQ To SQL Classes from the list. Name the new file Northwind.dbml and click the Add button. You should see an empty Object Relational Designer on the screen.

3. To add mappings, you will need a database connection. Select View  Server Explorer from the menu. Right-click on the Data Connections node and select Add Connection from the menu. Fill out the Add Connection window so it looks like the one in Figure 17.3, replacing the value in the Server Name textbox with your server and instance. Then click the OK button.

Figure 17.3 Creating the database connection

4. In the Server Explorer window, expand the connection that you created to the Northwind database. Then expand the Tables folder. Drag both the Customers and Orders tables from the Server Explorer to the left pane of the Designer. This will create a Customer entity and an Order entity. In the Designer, you will see that because the two tables are bound by a foreign key constraint on the SQL Server, that relationship is recognized in the entity model.

525

526

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

5. Take a moment to look at the entities in the Designer. Click on an entity in the Designer and you will see that the Properties window in the bottom right of the screen will update, giving you full control over the entity. You can change the name of any entity or property, alter its data mappings, and even add new properties that are based on data computations and custom logic.

6. Expand the Views folder in the Server Explorer. Drag the Sales by Category view to the left pane of the Designer. You will see that the Designer treats the view as an entity and it generates an entity class from the structure of the view.

7. Expand the Stored Procedures folder. Drag the CustOrderDetail procedure to either the left or the right pane of the Designer. No matter where you drop it, the result will be that it created a data function in the model. Currently, the object-relational mapping model that the Designer created looks like the illustration in Figure 17.4.

Figure 17.4 The Northwind sample entity model

Let’s look at a few key points in this model. First, if you go to the Solution Explorer window on the right of your screen and expand the Northwind.dbml node, you will see a Northwind. designer.cs file. Double click this icon to open the file. You will see the code that supports the model. The first class in the code file is called NorthwindDataContext. This class is your entry point into the model. This class knows how to connect to the underlying database and it has properties and methods that provide access to the other entities in the model. The Customers and Orders properties are references to the Customer and Order entities, respectively. You will see a Sales_By_Category property as well.

INTRODUCING LANGUAGE INTEGRATED QUERY (LINQ)

|

You will also see that the NorthwindDataContext class has a function called CustOrderDetail. This function represents the stored procedure of the same name. The return value of this function is a class type called CustOrderDetailResult. This class, also defined in the model, defines properties for all the individual data values that the stored procedure returns.

QUERYING SQL SERVER WITH LINQ Now that we have the entity classes with all of the required connectivity information, the next step is to use the classes to query the database. Suppose that we want to return a list of all the customers located in the United States of America and load the results in a data grid. You can follow these steps to accomplish this task.

1. Open the Visual Designer for Form1 in your application. From the toolbox, drag a DataGridView control and a Button control onto the surface of the form so that they look like the example in Figure 17.5.

Figure 17.5 Designing the Windows form

2. Double-click on the button in the Designer window to open the code stub for the buttonclick event. In this event stub, add the following code. //฀Establish฀the฀context NorthwindDataContext฀db฀=฀new฀NorthwindDataContext(); //฀Execute฀the฀LINQ฀query฀agains฀the฀data฀source var฀usCustomers฀=฀ ฀฀from฀c฀in฀db.Customers ฀฀where฀c.Country==”USA” ฀฀select฀new ฀฀฀฀{ ฀฀฀฀฀฀CompanyName฀=฀c.CompanyName, ฀฀฀฀฀฀City฀=฀c.City, ฀฀฀฀฀฀Country฀=฀c.Country ฀฀฀฀};

527

528

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

//฀Bind฀the฀results฀to฀the฀DataGridView฀control dataGridView1.DataSource฀=฀usCustomers;

3. Press the F5 key to run the application. When the form appears on the screen, click the button. This will populate the grid with data by executing the query. If you want to try out the stored procedure, add another button and use this code in its click-event handler. //฀Bind฀the฀results฀of฀the฀stored฀procedure฀to฀the฀DataGridView฀control NorthwindDataContext฀db฀=฀new฀NorthwindDataContext(); dataGridView1.DataSource฀=฀db.CustOrdersDetail(10660);

4. This code should return a single row of data for Order Number 10660 to the grid. Save your work. You should be aware that there are many features available in LINQ to SQL that we have not even hinted at. There are too many to cover in this book, but be aware that LINQ to SQL is quite flexible. LINQ to SQL can support transactional data modifications and will even allow you to map stored procedures to the insert, update, and delete operations. You can also override the default connection properties with alternative connection parameters when you create the DataContext object. These are just a few of the capabilities that LINQ to SQL provides.

The SQL Server Implications of LINQ to SQL As a database professional, you probably had a much different reaction to the code that you just saw than most client developers will have. The client developers love it. It makes things so easy. There is no more worrying about making connections and retrieving DataSets, and it is simple to provide criteria in a where clause or parameters for a stored procedure. What could be better? As a SQL professional, you might have different thoughts. •u฀ How are the connections made and how long are they held? •u฀ What mechanism does LINQ use to query the database? •u฀ What are the security implications of LINQ?

And in This Corner … We promise that we are not trying to start a fight here. Our intention is not to “spoil the party” with regard to LINQ to SQL. It is extremely important, however, to be fully aware of the implications of this kind of code. Every tool has its place, and only you and your colleagues can determine the best place for every technology in your environment. It is best to be informed before making those decisions, so that you will not be carried away by the excitement of using new and groovy technology.

The best thing that you can do to assess the impact of this approach on your database is to write some sample LINQ to SQL code and run some traces using SQL Profiler to determine the actual behavior of the tool. We highly recommend that you take the time to do this and evaluate the results. (This is sound advice to follow whenever you are investigating any new technology. Find out what is actually happening before you either put up roadblocks or jump on the bandwagon.)

INTRODUCING LANGUAGE INTEGRATED QUERY (LINQ)

|

If you run some traces, you should notice the following issues: Connections LINQ does an admirable job of reducing connection overhead. It fully utilizes ADO.NET connection pooling and when the application uses consistent connection properties, it pulls and releases connections to and from the pool effectively. Execution Process LINQ to SQL works through the SQL Native Client, which means that it adopts the standard behavior of the client when executing statements against the server. This default behavior is to pass dynamic SQL to the server, which it then executes using the sp_ executesql system stored procedure. A trace on the previous example (the one that loaded the grid with customers in United States) would show us a TextData value for the command that looks like this: exec฀sp_executesql฀N’SELECT฀[t0].[CompanyName],฀[t0].[City],฀[t0].[Country] FROM฀[dbo].[Customers]฀AS฀[t0] WHERE฀[t0].[Country]฀=฀@p0’,N’@p0฀nvarchar(3)’,@p0=N’USA’

This means that you have to contend with permissions issues relating to the execution of dynamic SQL, as well as the possibility of SQL injection issues, if the client developers are not properly scrubbing their parameters before passing them to the server. While not as exposed as using EXEC, there may still be some problems. Schema Dependence Although it is possible to override the connection parameters when instantiating the DataContext object, the schema from which you generate your entities is the schema you will be stuck with when coding to those entities. Any change of database schema would require you to generate your entities again. This could mean significant recoding for both the client as well as the customization work already done to those entities. The other option is to make the changes by hand. Neither approach is very appealing. Schema Requirements The quality of the generated entities depends on how well you are enforcing integrity on the server. (This is a best practice that you should be following anyway.) Primary keys, foreign keys, and other constraints are implemented into the entity structure. The quality of what you get out of the structure depends on what you put in it. For example, you will not be able to write LINQ queries that automatically perform entity correlation unless there are foreign keys present in the database that tell the entity generator how to correlate the data structures together. Again, we do not want to imply that LINQ is something you should fear. However, you should go into this model with your eyes wide open. Finally, we should address one more area of concern that deals with LINQ in general and not specifically to the LINQ to SQL model. Be careful that LINQ does not entice your developers to adopt coding practices that diverge from good database-coding standards. One of the hallmarks of good database-coding practice is that your query should only return the data that you will need and use. LINQ can seriously disrupt this standard. No matter what flavor of LINQ you might be using, you will be tempted to be more aggressive about the quantity of data that you return. Because it is so much easier now to requery the DataSet or XML document to retrieve the data that you want, you are likely to see more of an attitude among developers that if they retrieve more data now, they can avoid round trips to the server later. While this can be a good practice if you know that you will need and use that data,

529

530

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

often this practice is little more than “storing nuts for winter,” or bringing back additional data “just in case.” Avoid the temptation and do not let the practice take root in your organization or in your own development habits.

LINQ and the Entity Framework The ADO.NET Entity Framework is the logical successor to the LINQ to SQL model. What started in LINQ to SQL as a lightweight Object Relational Mapping (ORM) tool has begun to flesh out with the entity framework, including key issues such as support for multiple data sources through data providers, integration with business intelligence (BI) services, and a higher level of decoupling with the data tier than was available with LINQ to SQL. The entity model that you create using the ADO.NET Entity Framework supports two query approaches. You can either use LINQ to Entities or Entity SQL. LINQ to Entities should look very familiar now that you have been exposed to the LINQ to SQL model. Entity SQL is an attempt to use a more ad hoc SQL-like structure to query the entities. You are not actually performing ad hoc SQL, because everything will be processed by the entities, but the language does have that general appearance. The details of using the entity framework are very similar to the LINQ to SQL model. Instead of interacting with entity classes created through the LINQ to SQL Entity Designer, we will use the entity classes generated by Entity Framework Designers. The Entity Framework Designer relies on a new modeling environment that Microsoft calls the Entity Data Model (EDM). Microsoft patterned EDM after the Entity Relationship Model (ERM) that we use almost universally for relational database design. The intention is to take the best parts or ERM as it relates to data and apply it to Entity Modeling. Similar to LINQ to SQL, the Visual Studio project stored the entity information in an XML file. This time the file has an .edmx extension. We can create this by hand, which is the painful way, or we can use a wizard to create the initial bindings and then customize the model from there. In this section, we will once again walk through the process of setting up the entity model and then demonstrate how to query that model. Finally, we will look at the impacts of this technology on the SQL Server from the perspective of the DBA.

Where Is the Entity Framework? When the feature list for Visual Studio 2008 (VS 2008) was first released, Microsoft touted the ADO. NET Entity Framework as one of the substantial new additions to VS 2008. We had been able to do LINQ to SQL against SQL Server 2005 for quite some time in VS 2005, but it was time for the next step. Unfortunately, the entity framework was not ready for release when the release date came for VS 2008, and rather than delay the release of the entire product, Microsoft cut the framework from the product for release later. This feature has, however, been fully included in Visual Studio 2008 Service Pack 1. If you are walking through any of these examples with a release build of VS 2008 with no service packs or patches, then you will not see the options we will present. You must install Service Pack 1 first.

LINQ AND THE ENTITY FRAMEWORK

|

Creating and Querying the Entity Data Model The result of the model generation in the entity framework case is similar to the LINQ to SQL model, but the process is much different. We will not cover all of the nuances of the entity framework, but if you want to walk through the process of creating a simple model, follow these steps.

1. Start VS 2008 and create a new Windows Form project in Visual C#. Name the project NorthwindEDM and save it to a location of your choosing.

2. Add a new Entity Framework model by selecting Project  Add New Item from the menu. Select the ADO.NET Entity Data Model from the list. If you do not see this item in the list, then you must install the service pack (SP1) before you can continue. Name the model NWindCustomers.edmx and click the Add button.

3. In the Entity Data Model Wizard, select the option to generate the model from a database and click the Next button.

4. In the next screen, select the Northwind database connection that we created in the previous walkthrough. Notice on the bottom of the wizard form that it specifies the app.config settings name that it will use to save these settings. Click the Next button.

5. In the Object Selection screen, expand the Tables node and select the boxes next to the Customers and Orders tables. You could add many objects to your model, but we will use just these two. Notice that the namespace for the model classes is NorthwindModel. Click the Finish button. You should see a visual representation of the model in your Designer. Because the underlying tables are related through foreign keys, the model is automatically aware of the correlation and includes this in the model. On the right side of the screen, you should see the Model Browser window. If you do not see this, select View  Other Windows  Model Browser from the menu. This window allows you to see the details and properties of your entities, as well as the underlying data store. If you expand the Model Browser so that you can see the properties in the entities, it should look like the one in Figure 17.6. If you select the Customers entity in the Model Browser window, you should now see the properties of the entity in the Properties Window as well as the mapping information in the Mapping Details window. If the Mapping Details window does not appear, select View  Other Windows  Mapping Details from the menu. The mapping details are important because this is where you relate the entities to their underlying data source. If you want to remap an entity property to a different data structure, add a property, or remove a property, you would do it here.

Mapping for Reuse and Maintainability Entity mapping is a very important part of this process. We wish that we had more time to cover all of its intricacies here. At this point, all of the entities are mapped directly to data structures, but this does not have to be the case. You can remap entities using expressions. You can also add new entities based on existing ones but with different filter criteria. In the end, you can create an entity model that matches your business tier rather than your data structure, and that is the whole idea behind the entity framework. At that point, the EDM becomes a reusable transformational model that negotiates the differences between your logical business structure and physical data structure.

531

532

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

Figure 17.6 The Model Browser window

Querying the EDM is very similar to the LINQ to SQL code that we used previously. You have two options. You can either use LINQ to Entities or Entity SQL. Let’s take a look at both approaches.

1. In your Windows form, add a DataGridView control similar to the previous walkthrough. We will use this again for data binding. Also, add two buttons under the grid on the form. We will use one of these for the LINQ to Entities query and the other for the Entity SQL code.

2. Double-click the first button in the Designer to take you to the code stub for the click event. We will put a simple query here to return all data for all customers located in the United States. To do this, use the following code. //฀Create฀entity฀context NorthwindEntities฀context฀=฀new฀NorthwindEntities(); //฀Query฀entity฀model฀with฀LINQ var฀USCustomers฀= from฀customers฀in฀context.Customers where฀customers.Country฀==฀“USA” select฀customers; //฀Bind฀query฀results฀to฀grid dataGridView1.DataSource฀=฀USCustomers;

3. Run the application and click on the first button. The data grid should load with data. These will only be the customers located in the United States.

LINQ AND THE ENTITY FRAMEWORK

|

4. Code the second button to do the same thing with Entity SQL using the following code. Note that the ObjectParameter class is in the System.Data.Objects namespace. //฀Create฀entity฀context NorthwindEntities฀context฀=฀new฀NorthwindEntities(); //฀Query฀entity฀model฀with฀Entity฀SQL var฀USCustomers฀=฀context.Customers.Where ฀฀(“it.Country฀=฀@arg”,฀ ฀฀new฀System.Data.Objects.ObjectParameter(“Arg”,฀“USA”) ฀฀); //฀Bind฀query฀results฀to฀grid dataGridView1.DataSource฀=฀USCustomers;

5. Run the application and click the second button. Your grid should load with the same data as before. These will only be the customers located in the United States. In the Entity SQL code, you should note that the logic makes use of a “where” method. This is called a “builder” method and you use it to build the underlying query. You could have also used the argument “it.Country฀=฀‘USA’” and that would have worked as well, but parameterization is a better practice as it enforces type safety and is less prone to SQL injection attacks. Also, be aware that the “it” in it.Country is an alias intended to reference the contextual entity, in this case Customers.

The SQL Server Implications of the Entity Framework Although this technology is still new and it is certain to develop further, we can already see some interesting trends as it relates to SQL Server performance and security. Again, as with LINQ to SQL, the questions that a typical DBA would have deal with issues of connectivity, efficiency, performance, etc. The code that we just saw looks very similar to the LINQ to SQL model, but when you peel off the outer layers and look inside, you are really in a different world. The difference is that you have a significantly greater amount of control.

INTEROPERABILITY One of the great points about the entity framework is that it has significantly more interoperability with other database systems than the LINQ to SQL model. Because LINQ to SQL is dependent on the SQL Native Client, it suffers from the limitations that this defines. There were the issues with the default query-execution methods, over which you had no control. You also had to contend with the fact that the SQL Native Client provided support only for SQL Server. These two restrictions mean that you had little control and that there was little extensibility in the model. The entity framework functions much differently. Instead of the SQL Native Client, it uses a data source-provider model, much like standard ADO.NET. This makes it possible, and much more likely, that any database vendor can open up to the entity framework. Because the EDM is not vendor specific, you can reuse the same models again and again, mapping to a variety of different data platforms.

533

534

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

CONTROLLING THE PROCESS The entity framework is based on a layered model. Figure 17.7 illustrates this layered architecture. The client application only sees the object layer, while the database is only concerned with the storage layer and does not really care about what happens upstream. The magic happens in the middle, in the logical layer where the mapping and transformation take place.

Figure 17.7 The entity framework layers

Application Object Layer LINQ to Entities

Entity Query Expression

Logical Transformation Layer

Mapping

Execution

Storage Layer

The interesting aspect of this as it relates to the concerns of the typical DBA is that it gives you control over the process at any layer. For example, consider the Object layer. The application sees only this layer of the stack. In the previous example, we returned a set of customers that were located in the United States. We did this by using a where statement in our LINQ code that filtered out the other countries from the results. If the client developer wanted to process these results further, they could use the query as a source in yet another query, maybe adding a criterion for state as an example. This is possible because, by default, the return value of every query implements an interface called IQueryable. That means that every query can be further queried and refined through LINQ. This process is called query composition. Every additional query based on a query is translated into a single logical query expression, no matter how many times the query object has been further processed. The effect of this behavior is to minimize the data that is returned from the server by executing more restrictive and dynamic SQL. As a DBA, however, you may want to prevent this. If you want to restrict this behavior, you can modify the query objects in the model by casting them to the IEnumerable interface instead. The developer can still use LINQ to query IEnumerable objects, but because they are not IQueryable objects, the actual query expressions

LINQ AND THE ENTITY FRAMEWORK

|

cannot be composed. The result is that LINQ will use fixed logic in the initial query to pull the data from the server and any further processing done by additional queries is done on the client. The good part of this process is that although you have control over exactly what the framework executes on the server, to the client developer it makes no difference. Their code will look the same regardless. The only difference is the interface type that the queries assume. On the negative side, however, you might return more data to the client than is needed. Be careful that in your zeal to exercise control, you don’t force more expensive operations on the server—operations that could be done on the server more cheaply using the right query. At the data-store level, you can also use stored procedures for all processing. In the entity framework, you already have the ability to map stored procedures to insert and update operations for entities. That can be done directly in the mapping interface. You can also use stored procedures for all data extraction too, if you like, but when you do this, you lose the ability to support composable query behavior at the object layer due to the nature of stored procedure execution. The theory about stored procedures in general is that in the entity framework, stored procedures are much less important because the entity framework provider can handle all security-related problems and all query plans can be cached on the server to provide the same performance benefits as stored procedures. We are not necessarily advocating that you should drop all stored procedures in deference to the entity framework today, but be aware: this is definitely where Microsoft is going with the entity framework.

THE DBA PARADIGM SHIFT If you do not feel the earth moving under your feet, then we have not explained the entity framework properly. The database world is definitely about to shift. In the past your work as a DBA has been primarily confined to the database server. You make sure that things are as secure and as efficient as possible on the server, but your concern really stops there as soon as the bits are out of your servers. With the entity framework, this will change. In the context of the entity framework, the DBA and database developer roles must expand to include logical architecture as well as physical data storage architecture. The DBA or database developer must take a more active role in defining the mapping layer, controlling the physical execution process from the logical layer to the physical layer, and ensuring that the logical layer is constructed with the greatest degree of abstraction possible. For some database professionals, this is an exciting prospect. After all, living in that silo that is the database world can lead to feelings of isolation. The entity framework will require the database professional to emerge from that silo and think about data resources in terms of business processes, rather than just data services. Imagine a world where instead of spending your time creating and modifying stored procedures, you are creating entity models and managing the process of how those entities interact with your data. That is the future when the entity framework is a part of your architecture. For other database professionals, this is a frightening prospect. There are so many unknowns when we are dealing with new technologies. Not only do we have concerns about the database itself, but also about how we expand our skill set from TSQL into .NET and from ERM to EDM. Take comfort in the fact that this is an evolutionary and not a revolutionary process. All of the skills that you have today are still valid. Now it is time to expand them a little and take the next step into the future.

535

536

| CHAPTER 17

SQL SERVER AND THE .NET CLIENT

The Bottom Line Connect and query a SQL Server database using ADO.NET connected and disconnected techniques. Understanding how client developers make connection and query your databases will help you manage database resources better. Knowing the differences between connected and disconnected query strategies and how they affect the database is critical to effective database tuning. Master It For each class in the following list, determine whether you would use it for connected operations, disconnected operations, or both.

1. SqlConnection 2. SqlDataAdapter 3. DataSet 4. SqlCommand 5. SqlDataReader Use prominent special features of ADO.NET and the SQL Native Client. As ADO.NET matures, Microsoft continually adds special features to the API. As a database professional, it is critical that you understand what these features are so that you can assess their impacts on your databases. Master It For each of the statements below, specify True or False based on whether the statement will interleave in a MARS connection.

1. SELECT 2. RECEIVE 3. UPDATE 4. INSERT 5. GRANT 6. BULK฀INSERT Understand and implement simple examples using the new Language Integrated Query (LINQ) environment. LINQ is actually a collection of technologies. You can use LINQ to query a variety of different data structures. Your ability as a developer to leverage LINQ will depend on your understanding of the different environments where LINQ can operate. Master It For each of the following scenarios, specify whether you can use LINQ to address the situation, and if so, which variation of LINQ you would use.

1. A data access layer has passed an array of strings to your application and you must identify the string members that are over 10 characters in length.

2. You are connecting to an Oracle server and want to query the data from your data access layer through ADO.NET directly without returning a DataSet.

THE BOTTOM LINE

|

3. You are connecting to an Oracle server and want to query the data from your data access layer through ADO.NET directly by returning a DataSet.

4. You have created a web application that allows a client to upload sample Simple Object Access Protocol (SOAP) messages. You want to query the SOAP message to show the user what the parameters of their call will be in that message. Understand and implement simple examples using the ADO.NET Entity Framework. Although it is new technology, the entity framework promises to change the way that we look at distributed solutions. Understanding the general architecture of the framework will be helpful as you decide where this technology fits into your enterprise solution. Master It

Answer the following questions relating the entity framework.

1. What two query options are supported by the entity framework? 2. In which architectural layer of the framework does the database server exist? 3. Is the entity framework only usable by SQL Server? 4. What is a composable query?

537

Chapter 18

SQL Server and the Common Language Runtime Beginning with SQL Server 2005, Microsoft added integration with the .NET Common Language Runtime (CLR) as one of its features. Including the CLR in SQL Server has provided both a bane and a benefit to the SQL developer and administrator. It provides an incredible source of power and potential to your server applications, but it also comes with costs that include resource consumption and additional security complications. This feature is not intended for every application and not every kind of server application can benefit from this capability. Those that can, however, have a new tool at the ready. This chapter addresses the concepts behind the CLR and its essential architecture, particularly how it interfaces with SQL Server. We will also look at the specifics of how to create and deploy CLR-based artifacts such as stored procedures and functions using C#. In this chapter, you will learn to: •u฀ Enable and configure the CLR in SQL Server 2008 •u฀ Create managed objects for the SQL Server CLR •u฀ Deploy managed objects into the SQL Server CLR •u฀ Manage security for the SQL Server CLR

CLR Concepts Being a Transact-SQL expert is not enough anymore. Although Transact-SQL continues to work well, you have additional options now. With the integration of the .NET CLR into SQL Server, now you can create all of the artifacts that you know in a whole new way. Stored procedures, views, triggers, and functions are just some of the artifacts that you can now create with any .NET language and deploy into SQL Server. It’s a whole new world. Microsoft’s intent with CLR integration is not to make Transact-SQL obsolete. TSQL is still the best choice for many operations on the server that perform data services as their primary operations. If anything, the intent is to eliminate the need for extended stored procedures in SQL Server. CLR objects can do all of the things that extended stored procedures do, such as execute processor-intensive code more efficiently than TSQL and provide a mechanism for interacting with the platform.

540

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

Obsolescence Can Be a Good Thing With the impending deprecation of extended stored procedures in SQL Server, CLR objects are more important than ever. If you rely on custom extended stored procedures for your applications, this might be a good time to start evaluating how they can be rewritten in a .NET language utilizing the CLR. If you need to create new extended stored procedures today, you should consider the CLR as your best option now. The good news is that creating objects for the CLR is a much easier process than creating extended stored procedures. This provides a greater degree of accessibility for applications that could benefit from the features that these extended procedures could provide but did not have the resources to create.

In Chapter 17, “SQL Server and the .NET Client,” we discussed how to write C# code for interacting with SQL Server. What is different about this chapter is that we will be writing .NET code that will run within SQL Server as opposed to in a separate client application or component tier. This is an important distinction, and one that requires more background in the CLR and its integration with SQL Server.

CLR Terminology First, let’s cover some definitions that you will see frequently in this chapter. Once we have the framework of common definitions, we can look at the specifics of how the CLR is implemented. Common Language Runtime The Common Language Runtime (CLR) is the operating environment for .NET code. Instead of the operating system directly executing the code, in the .NET world, all code is executed by the CLR. You can think of it as a sandbox in which the .NET code runs, isolated from the operating system and other non-.NET code. This includes numerous components such as the just-in-time (JIT) compiler, security engine, debug engine, and execution engine. Managed Code All Microsoft .NET code created in languages like VB.NET or C# is called managed code. Microsoft calls it managed code because the CLR manages all resources as opposed to the developer writing code to do it. For example, the CLR manages all memory allocation and garbage collection so the developer does not need to write code to allocate and destroy memory. All SQL Server CLR artifacts are managed objects. Application Domain Also called an app domain, this is an isolated execution environment within a CLR instance. When managed code loads, it does so within an app domain. It is possible for a single CLR to contain many app domains. The purpose is to isolate managed objects into their own operating space for security and stability reasons, preventing failures in one app domain from adversely affecting the processing in another app domain. Code Access Security Often called CAS, this is a managed code security feature that allows an administrator to assign execution policies to code. The intention is to be able to control which code elements have permissions to call other code elements. This can prevent an unauthorized process from calling a sensitive piece of code by controlling the policy for the called code. SQL Server uses CAS to control the level of access that managed objects have in SQL Server and the platform as a whole.

CLR CONCEPTS

|

Class A class, as it relates to SQL Server managed objects, is a structure that defines a set of related managed operations such as functions or stored procedures. Although in the true object-oriented mindset, a class is a type that represents an artifact in your application design, it is easier to think of a class in this sense as simply a collection of managed artifacts that you can call from your SQL Server code. Assembly An assembly is the basic unit of packaging and deployment in .NET. You can create multiple classes and deploy them in a single assembly. The TSQL code has a CREATE฀ ASSEMBLY statement that you can use to import the assembly metadata into the SQL Server catalog, making the members available for other SQL Server code. You must package any .NET code that you want to use in SQL Server into an assembly and deploy that assembly to SQL Server before the server can use the code. Framework Class Library To provide a basic set of functionality for managed applications, Microsoft ships a library of classes that provide basic application functionality, including things like string management, threading, data access and web development. The class library is very large. You do not have to know the entire library to be able to create objects for SQL Server. You will, however, need to use some of the classes in the library to create meaningful managed objects.

Don’t Panic! This is Just an Overview Some of you may have significant experience in writing .NET code in C#, and for others this may be a brand new experience. Our goal for this chapter is not to force you to wade through a ton of C# code. This is not a C# book. But we do want to at least provide some exposure to how the CLR works in SQL Server 2008 so that we can lift the veil of mystery, if only a little. For this reason, please be aware that our intention here is not to provide exhaustive coverage of CLR-based objects. Most of you who are database administrators probably will not be writing a lot of that code anyway, and some of these objects can be a little involved to create. We will cover only the most common scenarios—hopefully, at a sufficient level of depth so that the next time you are at a party and topic comes up, you will be able to speak intelligently about SQL Server CLR integration. It will undoubtedly make you the most popular person in the room.

Enabling the CLR For security reasons, the CLR in SQL Server 2008 installs as a disabled feature. If you want to be able to deploy and use managed objects in SQL Server, you must enable this option. This is an advanced option in SQL Server. The code to perform this operation looks like this. sp_configure฀‘show฀advanced฀options’,฀1; GO RECONFIGURE; GO sp_configure฀‘clr฀enabled’,฀1; GO RECONFIGURE; GO

541

542

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

The effect of this code is to allow the CLR to activate an app domain, hosted by SQL Server 2008, which provides a container in which the managed code can run. If you disable the CLR integration, it will terminate all executing routines and unload all app domains. You must have appropriate ALTER฀SETTINGS permissions to enable this option. This permission is implicitly held by the serveradmin and sysadmin roles.

You Cannot Entirely Disable the CLR Be aware that this option only controls whether the CLR is usable for your custom content. The CLR in SQL Server is always available for internal use. There are SQL Server 2008 features, such as the spatial datatypes, that are implemented in the CLR as managed objects. They are always available regardless of the CLR Enabled setting on the server.

After enabling the CLR, all managed code will automatically have access to a limited set of assemblies in the framework class library. Because many element of the .NET framework, such as windowing operations, are not relevant to SQL Server, they are not implicitly supported. The assemblies that SQL Server implicitly supports are Microsoft.VisualBasic Microsoft.VisualC mscorlib System System.Configuration System.Data System.Data.OracleClient System.Data.SqlXml

System.Deployment System.Security System.Transactions System.Web.Services System.Xml System.Core.dll System.Xml.Linq.dll System.Deployment

Any assemblies that SQL Server does not implicitly support are still available for you to use if you register the necessary assemblies in SQL Server using the CREATE฀ASSEMBLY statement. There may still be some security limitations, however, as not all code is accessible through CAS in SQL Server.

Creating Managed Objects in SQL Server Microsoft Visual Studio 2008 is the preferred tool for creating managed objects for SQL Server. This development environment simplifies the process of creating classes and assemblies for SQL Server 2008. Using one tool, you can create the objects and deploy them in SQL Server for testing. In this section, we will look at the process of setting up a Visual Studio project for creating managed objects and then look at how to create the most common managed objects for SQL Server, namely the functions and stored procedures.

CREATING MANAGED OBJECTS IN SQL SERVER

|

Visual Studio 2008 Compatibility The release of Visual Studio 2008 significantly predated the release of SQL Server 2008. As a result, Visual Studio does not have the capability of integrating with SQL Server 2008 right out of the box. Microsoft added this feature in Service Pack 1 of Visual Studio. You will need to install this service pack before you will be able to walk through any of the examples illustrated in this chapter. We will be using the C# language for all of the code samples in this chapter. We have configured Visual Studio using the C# code settings option, so don’t worry if your screens look a little different than those illustrated here—it may be because of the configuration. They should not be very difficult to translate.

Setting Up the Project Environment The first step is to create a Visual Studio SQL Server project.

1. Begin by starting Visual Studio 2008. From the main menu in Visual Studio, select File  New  Project. This will give you the New Project dialog.

2. Drill into the Visual C# tree and locate the node for Database Projects. You should see a dialog like the one illustrated in Figure 18.1. We filled out this dialog to create a new SQL Server project called AWManagedCode. After filling out the dialog, click the OK button.

Figure 18.1 Creating a new SQL Server project

3. After clicking the OK button, you will be presented with the New Database Reference dialog, as pictured in Figure 18.2. (If you already have any data connections defined, you will see a list of connection options and will have to click the Add New Reference button to open the dialog in Figure 18.1.) This dialog allows you to define a connection between the project and a SQL Server instance, and it allows your project to deploy managed

543

544

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

objects to SQL Server directly from Visual Studio for testing purposes, which is very convenient. We are connecting to an instance with an AdventureWorks2008 database, which we will use for our examples.

Figure 18.2 Configuring the database connection

4. After you advance beyond this dialog, you may see a message box asking you if you want to enable SQL Server debugging for this connection. In this example, we will turn this on, as we may want to step through the managed code running in the SQL Server hosted app domain. If you do not turn this on now, you can always enable it later in Visual Studio through the Server Explorer window.

5. You should now have an open project in Visual Studio. The Solution Explorer window in the right portion of the screen ought to look like the illustration in Figure 18.3.

Figure 18.3 The Solution Explorer window

6. In this image, you will see a folder called Test Scripts. This folder will contain the tests that you will use for your managed objects. When you run a test script, Visual Studio performs a deployment of the assembly into the registered SQL Server instance and executes the test script on that server.

CREATING MANAGED OBJECTS IN SQL SERVER

|

7. Right-click any test script in this folder and select a menu option to set that script as the default debug script. Visual Studio will then run that script when you start the project debugger in Visual Studio by clicking the Run button in the toolbar or pressing Alt+F5 on your keyboard. You can also create additional test scripts if you like. Right-click the Test Scripts folder and select Add New Test Script from the menu. This will add a file to the Test Scripts folder. To debug a test script other than the default, right-click that script in the list and select Debug Script from the menu. Using this approach, you can have a wide array of different test options and can execute any of them whenever you like.

Creating Managed Functions The simplest managed object that you can create in Visual Studio is a function. Remember that SQL Server functions come in two varieties, scalar and table-valued. Visual Studio supports these same two options. Scalar functions return a single value. They are the most common types of functions and are very typical in most programming languages. Table-valued functions return a table structure that you can select from and use in place of a table in many situations. We will start by looking at scalar functions and then see how to implement table-valued functions.

MANAGED SCALAR FUNCTIONS Managed scalar functions are very similar to their TSQL counterparts. They can accept parameters and will return a single scalar value as a result. If you have ever written a function in C# or any other programming language, the process will look very familiar.

1. To begin, you must add a class to the project that will contain your function. To add a class that is preconfigured for a function, go to the Solution Explorer window in Visual Studio. Click on the project in the solution to which you want to add the function, and select Project from the main menu in Visual Studio.

2. At the top of this menu, you will see a list of artifacts that you can add to your SQL Server project. Locate User-Defined Function in the list and select it from the menu.

3. In the Add New Item dialog, you will need to provide a name for the function. Our sample function will be a simple mathematical function that will calculate the cube of an integer by raising it to the power of 3 and returning the result. Set the name as CubeValue.cs and click the Add button.

4. You should see the following code in the body of the listing. public฀partial฀class฀UserDefinedFunctions { ฀฀฀฀[Microsoft.SqlServer.Server.SqlFunction] ฀฀฀฀public฀static฀SqlString฀CubeValue() ฀฀฀฀{ ฀฀฀฀฀฀฀฀//฀Put฀your฀code฀here ฀฀฀฀฀฀฀฀return฀new฀SqlString(“Hello”); ฀฀฀฀} };

545

546

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

This code defines a class called UserDefinedFunctions. Visual Studio 2008 supports a concept called partial classes. This means that a single class can be distributed across multiple files in a Visual Studio project. As long as all the files are present when the project compiles, Visual Studio will assemble the files into a single class. This is helpful because you can define each function in its own file, but the compiler can still aggregate them into a single class, which makes deployment easier. You will also notice an attribute tag on top of the function that marks this as a SqlFunction. This attribute is actually a class in the framework class library. It provides instructions to the compiler to tell it to compile it as a SqlFunction as opposed to a regular managed function. Only SqlFunction objects are callable as functions inside SQL Server from TSQL code. You will need to rewrite this code a bit to suit your purpose. Notice that the function currently accepts no parameter and returns a SqlString as its return value. This is not what we want. We can do much better than a simple “hello world” function, right? You can use any SQL Server datatypes in your function except the following: varchar char roversion text ntext

image timestamp table cursor

Why No char or varchar? At first glance it seems ridiculous that you can’t use char or varchar types in your functions, but there is a reason. Managed code uses Unicode strings and the char and varchar datatypes are not Unicode. The SqlString class in the System.Data.SqlTypes .NET namespace represents a variablelength collection of Unicode characters, essentially equivalent to an nvarchar datatype in SQL Server. You may want to look at the type list in the Visual Studio 2008 documentation for the classes in the System.Data.SqlTypes namespace to get more familiar with your typing options.

After rewriting our procedure to accept an integer as its parameter and returning an integer as a return value, the code would look like this. Note that we have also modified the logic of the function to provide the desired implementation. public฀partial฀class฀UserDefinedFunctions { ฀฀฀฀[Microsoft.SqlServer.Server.SqlFunction] ฀฀฀฀public฀static฀SqlInt32฀CubeValue(SqlInt32฀value) ฀฀฀฀{ ฀฀฀฀฀฀฀฀return฀(SqlInt32)Math.Pow((Int32)value,฀3); ฀฀฀฀} };

CREATING MANAGED OBJECTS IN SQL SERVER

|

This function now accepts a SqlInt32 as a parameter and returns the same type. Because the SqlInt32 type is different in structure from the .NET datatype for Int32, we had to do some datatype conversion. For example, the syntax (Int32)value converts the parameter named value from a SqlInt32 type to a standard .NET Int32 type. You will also see that we used a framework library class called Math in this example. This class has a method called Pow that you can use to raise a base value to an exponent. One of the advantages of using managed code is that you have almost the complete framework library at your disposal, which allows you to develop more complex routines than you can in TSQL. To test this function, you will need to add a test statement to the test script. You can either use the one that Visual Studio created for you or create your own.

1. On the desired test script, add the following statement: SELECT฀dbo.CubeValue(10)฀as฀CubeResult;

2. Assuming that there are no other test statements in your test script, executing this script should open an Output window in Visual Studio that looks something like the one pictured in Figure 18.4.

Figure 18.4 The Test Output window

When you debug the test script, it will compile the project and deploy the managed assembly to the referenced server. Notice the results of the function are provided in the middle of the output surrounded by diagnostic and status information.

3. Open SQL Server Management Studio and connect the Object Browser to the instance of SQL Server referenced by the project. You should be able to see the managed assembly in the list for the target database, as illustrated in Figure 18.5. You should also be able to execute the previous test statement in a new Query window connected to the database.

547

548

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

Figure 18.5 Viewing the deployed assemblies

Now the managed assembly is fully deployed. Although you will not use Visual Studio to perform production deployments, this capability is very convenient when developing and testing managed objects.

It Looks the Same to Me The nice thing about the managed objects is that once you have registered the assembly and added the object metadata to your database, you can call them in your TSQL code just like any other TSQL object. This makes it entirely transparent to a TSQL developer or client developer. They do not need to know if the target object is a native TSQL object or a managed object. The call is the same.

MANAGED TABLE-VALUED FUNCTIONS Unlike a scalar function, a table-valued function (TVF) requires two methods per function. This is because each function must have multiple methods, each of which marks a separate activity or step in the process of returning the table data to the caller. Each TVF requires at least the following: An Init Method The entry point into the TVF, which returns the .NET type IEnumerable. This method can accept parameters to be passed to the TVF. Decorate this method with the SqlFunction attribute.

CREATING MANAGED OBJECTS IN SQL SERVER

|

A FillRow Method This method executes once for each row to be populated into the results using output parameters to populate the output table. To get a feel for the structure of a TVF, look at the code in Listing 18.1. This example shows a function that selects data from the Person.Person table in the AdventureWorks2008 database based on a range of BusinessEntityID values.

Listing 18.1

A Managed Table-Valued Function

using฀System; using฀System.Data; using฀System.Data.SqlClient; using฀System.Data.SqlTypes; using฀Microsoft.SqlServer.Server; using฀System.Collections; public฀partial฀class฀UserDefinedFunctions { ฀฀฀฀[SqlFunction(Name฀=฀“PersonTable”, ฀฀฀฀FillRowMethodName฀=฀“FillRow”,฀TableDefinition฀=฀“FirstName฀nvarchar(100),฀ LastName฀nvarchar(100)”, ฀฀฀฀DataAccess฀=฀DataAccessKind.Read)] ฀฀฀฀public฀static฀IEnumerable฀InitPersonTable(SqlInt32฀StartID,฀SqlInt32฀EndID) ฀฀฀฀{ ฀฀฀฀฀฀฀฀using฀(SqlConnection฀cn฀=฀new฀SqlConnection(“context฀connection=true”)) ฀฀฀฀฀฀฀฀{ ฀฀฀฀฀฀฀฀฀฀฀฀SqlCommand฀cmd฀=฀new฀SqlCommand ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀ (“SELECT฀Firstname,฀LastName฀FROM฀Person.Person฀WHERE฀BusinessEntityID฀BETWEEN฀@ start฀and฀@end”); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@start”,StartID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@end”,฀EndID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Connection฀=฀cn; ฀฀฀฀฀฀฀฀฀฀฀฀DataSet฀ds฀=฀new฀DataSet(); ฀฀฀฀฀฀฀฀฀฀฀฀SqlDataAdapter฀ad฀=฀new฀SqlDataAdapter(cmd); ฀฀฀฀฀฀฀฀฀฀฀฀ad.Fill(ds); ฀฀฀฀฀฀฀฀฀฀฀฀return฀ds.Tables[0].Rows; ฀฀฀฀฀฀฀฀} ฀฀฀฀฀} ฀฀฀฀public฀static฀void฀FillRow(object฀row,฀out฀SqlString฀FirstName,฀out฀SqlString฀ LastName) ฀฀฀฀{ ฀฀฀฀฀฀฀฀DataRow฀currentRow฀=฀(DataRow)row; ฀฀฀฀฀฀฀฀FirstName฀=฀currentRow[“FirstName”].ToString(); ฀฀฀฀฀฀฀฀LastName฀=฀currentRow[“Lastname”].ToString(); ฀฀฀฀} }

549

550

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

There are a number of points that you should observe in this code. First, note that the InitPersonTable() method is decorated with the SQLFunction attribute and includes the name of the function. When you deploy this function in SQL Server, you will use the configured function name. There is also an attribute that identified the FillRow method for this function. You can name these methods anything you like as long as they are decorated correctly with attributes. There is also a DataAccess attribute on the Init method. This attribute allows you to execute ADO.NET in the Init method as needed using a context connection. Notice the line of code that creates the connection object. The connection string simply states that it should use the context connection, which is a connection to the database in which the function is deployed and executing. Without this attribute, you would not be able to use the context connection. The Init method returns an enumerable object, which in this case is the rows collection of the data table. For each element in the collection, the function calls the specified FillRow method. This method evaluates the data row, extracts the data to be loaded into the returned table object and loads that data into output parameters. To test this function, add a statement like this to the test script and debug as before. SELECT฀*฀FROM฀dbo.PersonTable(1,100)฀as฀PersonList;

The parameters passed into the function are then passed into the SQL code in the body of the function, which provides the boundaries for the execution. Once again, you can also execute this function from the SQL Server Management Studio if you like.

Creating Managed Stored Procedures Stored procedures are extremely common and most SQL Server applications have a significant number of stored procedures that do the real work of the application. Not all stored procedures can benefit from executing in the CLR. Most stored procedures that do simple data access are better off to remain as TSQL operations. But for those cases where a stored procedure does significant processor-intensive operations, must interact with the platform outside of SQL Server, or contains logic that is too cumbersome to write in TSQL code, a managed procedure may do the trick. Stored procedures are implemented as a single method in the class. Adding a new stored procedure object through Visual Studio will add a new file in a partial class called StoredProcedures. The stored procedure can accept parameters as needed, including output parameters. You can also use stored procedures to send tabular data back to the client. The techniques are a little different from one another, so we will look at each individually.

USING OUTPUT PARAMETERS Conceptually, this is just the same as a parameter marked as OUTPUT in a TSQL stored procedure. A parameter to a C# method that is marked with the out keyword must be initialized in the procedure before the procedure returns. The calling procedure then captures the data in the arguments that is passes to the procedure. Suppose that you wanted to get a count of persons from the Person.Person table that were between a specific beginning and end value for BusinessEntityID. You could use an output parameter to provide that information to the caller. Listing 18.2 illustrates the use of output parameters as described.

CREATING MANAGED OBJECTS IN SQL SERVER

Listing 18.2

|

551

Output Parameters in a Managed Stored Procedure

using฀System; using฀System.Data; using฀System.Data.SqlClient; using฀System.Data.SqlTypes; using฀Microsoft.SqlServer.Server; public฀partial฀class฀StoredProcedures { ฀฀฀฀[Microsoft.SqlServer.Server.SqlProcedure] ฀฀฀฀public฀static฀void฀GetPersonCount(SqlInt32฀StartID,฀SqlInt32฀EndID,฀out฀SqlInt32฀ PersonCount) ฀฀฀฀{ ฀฀฀฀฀฀฀฀using฀(SqlConnection฀cn฀=฀new฀SqlConnection(“context฀connection=true”)) ฀฀฀฀฀฀฀฀{ ฀฀฀฀฀฀฀฀฀฀฀฀SqlCommand฀cmd฀=฀new฀SqlCommand ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀ (“SELECT฀Count(*)฀as฀PersonCount฀FROM฀Person.Person฀WHERE฀BusinessEntityID฀BETWEEN฀ @start฀and฀@end”); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@start”,฀StartID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@end”,฀EndID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Connection฀=฀cn; ฀฀฀฀฀฀฀฀฀฀฀฀cn.Open(); ฀฀฀฀฀฀฀฀฀฀฀฀PersonCount฀=฀(int)cmd.ExecuteScalar(); ฀฀฀฀฀฀฀฀฀฀฀฀cn.Close(); ฀฀฀฀฀฀฀฀} ฀฀฀฀} };

Notice that the method marks the PersonCount parameter as out, while the body of the stored procedure assigns a value to this parameter based on the count from the underlying table. You will also notice that it is not necessary to use the DataAccess attribute in the stored procedure as we had to do in a function. This is because it is much more common that a stored procedure will interact with stored data than a function will, so this feature is assumed with stored procedures whereas it is not assumed with functions. This procedure is called the same way as any other stored procedure call that contains output parameters. To test your code, include the following in your test script and begin the debugger. DECLARE฀@vCount฀ int; EXEC฀dbo.GetPersonCount฀100,฀250,฀@vCount฀OUTPUT; SELECT฀@vCount;

In your Output window, you should see the scalar value reported. Again, you can also execute this code from SQL Server Management Studio in exactly the same way.

552

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

ACCESSING TABULAR DATA Many stored procedures return result sets, so this is a common feature that you will need to support in your managed stored procedures. If you know how to write ADO.NET code, then the job is simple. You need only create a command object that represents the code that you want to send back to the client. You can easily send this data using a pipe object that is accessible through the implicit context object. Look at Listing 18.3 for an example.

Listing 18.3

Returning Tablular Data from a Managed Stored Procedure

using฀System; using฀System.Data; using฀System.Data.SqlClient; using฀System.Data.SqlTypes; using฀Microsoft.SqlServer.Server; public฀partial฀class฀StoredProcedures { ฀฀฀฀[Microsoft.SqlServer.Server.SqlProcedure] ฀฀฀฀public฀static฀void฀GetPersonList(SqlInt32฀StartID,฀SqlInt32฀EndID) ฀฀฀฀{ ฀฀฀฀฀฀฀฀using฀(SqlConnection฀cn฀=฀new฀SqlConnection(“context฀connection=true”)) ฀฀฀฀฀฀฀฀{ ฀฀฀฀฀฀฀฀฀฀฀฀SqlCommand฀cmd฀=฀new฀SqlCommand ฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀฀ (“SELECT฀FirstName,฀LastName฀FROM฀Person.Person฀WHERE฀BusinessEntityID฀BETWEEN฀@ start฀and฀@end”); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@start”,฀StartID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Parameters.AddWithValue(“@end”,฀EndID); ฀฀฀฀฀฀฀฀฀฀฀฀cmd.Connection฀=฀cn; ฀฀฀฀฀฀฀฀฀฀฀฀cn.Open(); ฀฀฀฀฀฀฀฀฀฀฀฀SqlContext.Pipe.ExecuteAndSend(cmd); ฀฀฀฀฀฀฀฀฀฀฀฀cn.Close(); ฀฀฀฀฀฀฀฀} ฀฀฀฀} };

You will note that even though the stored procedure returns a result set, the method that defined the procedure still returns void. The return data is sent back to the client through the pipe exposed by the SqlContext object. The ExecuteAndSend() method is very convenient. Although the pipe has a Send() method that can pass a data reader or a string message back to the client, the ExecuteAndSend() method eliminates the need to cache the data reader in a variable and send it through the pipe. In this case, the pipe object takes care of executing the command and piping the results directly back to the caller. Executing this procedure, again, is just like any other procedural object. This code in your test script should do the trick. EXEC฀dbo.GetPersonList฀100,฀250;

CREATING MANAGED OBJECTS IN SQL SERVER

|

There’s nothing to it, right? Once you have created the managed object in Visual Studio and deployed it to the SQL Server, you can use it in SQL Server just as you would any other object.

Create Managed Datatypes This feature is one of our favorites. When you create managed datatypes for SQL Server, you are not really creating a new type, nor are you duplicating the concept of the user-defined type (UDT) in SQL Server, which is nothing more than a subtype. Using Visual Studio, you have the ability to create compound types for more complex data interactions. For example, suppose that you wanted to store information about locations on a geometric point system. If you were working with plane coordinates, you would have both an X-value and a Y-value to identify the point. Using SQL Server types, your database would have to have a column for the X-value and another column for the Y-value. Additionally, the client would have to pass these values to an INSERT statement as two separate values. It would be nice if we could have a single type called Point that could store this ordered pair as a complex value. This is exactly what the managed type offers.

Managed Types in Action SQL Server 2008 includes support for a new feature called spatial data. This feature allows you to store information about geometric or geographic objects in the database. Because these artifacts are complex, often requiring more than a single data point, SQL Server uses .NET managed types for these data elements. Chapter 19, “Using Spatial Data,” discusses these types in more detail.

To begin, you need to add a new item to your Visual Studio project. This item will be a userdefined type. The filename will be Point.cs, and this will create a struct called point, which implements the INullable interface. The entire struct is needed to provide support for the type. You will notice that a number of methods have been provided for you already. We will look at the completed code for this type and walk through these methods one at a time. The code is provided in Listing 18.4.

Listing 18.4

Creating a Managed Type

using฀System; using฀System.Data; using฀System.Data.SqlClient; using฀System.Data.SqlTypes; using฀Microsoft.SqlServer.Server; [Serializable] [Microsoft.SqlServer.Server.SqlUserDefinedType(Format.Native)] public฀struct฀Point฀:฀INullable { ฀฀฀฀private฀฀int฀_x; ฀฀฀฀private฀฀int฀_y; ฀฀฀฀private฀bool฀m_Null; ฀฀฀฀public฀override฀string฀ToString() ฀฀฀฀{

553

554

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

฀฀฀฀฀฀฀฀return฀X.ToString()฀+฀“,”฀+฀Y.ToString(); ฀฀฀฀} ฀฀฀฀public฀bool฀IsNull ฀฀฀฀{ ฀฀฀฀฀฀฀฀get ฀฀฀฀฀฀฀฀{ ฀฀฀฀฀฀฀฀฀฀฀฀return฀m_Null; ฀฀฀฀฀฀฀฀} ฀฀฀฀} ฀฀฀฀public฀static฀Point฀Null ฀฀฀฀{ ฀฀฀฀฀฀฀฀get ฀฀฀฀฀฀฀฀{ ฀฀฀฀฀฀฀฀฀฀฀฀Point฀h฀=฀new฀Point(); ฀฀฀฀฀฀฀฀฀฀฀฀h.m_Null฀=฀true; ฀฀฀฀฀฀฀฀฀฀฀฀return฀h; ฀฀฀฀฀฀฀฀} ฀฀฀฀} ฀฀฀฀public฀static฀Point฀Parse(SqlString฀s) ฀฀฀฀{ ฀฀฀฀฀฀฀฀if฀(s.IsNull) ฀฀฀฀฀฀฀฀฀฀฀฀return฀Null; ฀฀฀฀฀฀฀฀Point฀p฀=฀new฀Point(); ฀฀฀฀฀฀฀฀string฀sVal฀=฀(string)s; ฀฀฀฀฀฀฀฀string[]฀pair฀=฀sVal.Split(new฀char[]฀{฀‘,’฀}); ฀฀฀฀฀฀฀฀p.X฀=฀int.Parse(pair[0]); ฀฀฀฀฀฀฀฀p.Y฀=฀int.Parse(pair[1]); ฀฀฀฀฀฀฀฀return฀p; ฀฀฀฀} ฀฀฀฀public฀int฀X ฀฀฀฀{ ฀฀฀฀฀฀฀฀get฀{return฀_x;} ฀฀฀฀฀฀฀฀set฀{_x฀=฀value;} ฀฀฀฀} ฀฀฀฀public฀int฀Y ฀฀฀฀{ ฀฀฀฀฀฀฀฀get฀{฀return฀_y;฀} ฀฀฀฀฀฀฀฀set฀{฀_y฀=฀value;฀} ฀฀฀฀} }

What Is a Struct? Unless you are a hard-core .NET programmer, you really don’t need to know the difference between a class and a struct. For right now, just consider the struct as a lightweight class. It can do almost everything a class can do, but its memory mapping in .NET is a little different than you get with a class. Don’t worry about the details. Let your .NET programmers sweat the details.

DEPLOYING MANAGED OBJECTS IN SQL SERVER

|

The first thing we did in this code sample was define the variables. You will need storage for all of the data that the type can manage. In this case, there is a variable for both the X- and Y-value and a variable to store a flag for null if the user attempts to assign a value of null to the datatype. Notice that the variables are private. At the bottom of the code you will see properties for X and Y. These properties read and write the values of the private variables. All access to the variables will go through these properties. You could also add additional methods to the type if you like, such as a calculation based on the compound data. These methods are callable through the SQL Server variables. The ToString() method indicates what you will return when the complex type is selected. In this case, we take the two integers and concatenate them with a comma, creating the ordered pair from the individually stored data. The Parse() method goes the other way around. When an ordered pair is assigned to the datatype as a string, the Parse() method breaks the pair into pieces and assigns the appropriate values to the properties. The remaining methods do null handling and null testing, reading and assigning null values as necessary. To test this code, add the following snippet to the test script. Notice that you assign the value as a string and access the public properties using standard “dot” notation. DECLARE฀@vPoint฀Point; SET฀@vPoint฀=฀‘1,4’; SELECT ฀฀@vPoint.X฀as฀X,฀ ฀฀@vPoint.Y฀as฀Y;

If you followed through all of the examples so far, your project, which will become your assembly, should have two classes with two objects each plus the struct for the Point type. We have been deploying these through Visual Studio, but you may not always have that option. To give you more choices, we’ll make deployment our next topic.

Deploying Managed Objects in SQL Server In this section, we will look at the complete deployment process including registering the assemblies and adding the managed objects to the database. Deploying the managed objects in SQL Server is a two-step process. You must first register the assembly with SQL Server and then add the functions and stored procedures from the assembly. Conceptually, it is very much like adding references to extended stored procedures. After deploying the DLL file to the server, you must add the metadata to SQL Server that references the functions in the DLL.

Creating Assemblies Before you can use the managed objects in the assemblies that you just created, you must first register those assemblies in SQL Server. When you register an assembly in SQL Server, it copies the content of the assembly to the system catalog, making it available to any caller from any location, whether that assembly is registered on their computer or not. This also removes the dependency to a physical file, so after you have registered the assembly on the server, you do not need to retain the physical file or maintain a connection to the computer from which the physical file deployed. There are two ways to register the assembly, either with the SQL Server Management Studio or through TSQL code. Each approach has its advantages. We will look at both methods.

555

556

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

Clean Up Before You Continue If you are following along with these examples, you will need to remove the assembly and objects from the AdventureWorks2008 database before you will be able to continue with these examples. Running the test scripts in Visual Studio performed a temporary deployment, so you are going to have to remove those objects. For right now, just drop the objects. You can use this script if you like. USE฀AdventureWorks2008; DROP฀PROC฀dbo.GetPersonCount; DROP฀PROC฀dbo.GetPersonList; DROP฀FUNCTION฀dbo.CubeValue; DROP฀FUNCTION฀dbo.PersonTable; DROP฀TYPE฀dbo.Point; DROP฀ASSEMBLY฀AWManagedCode; GO

CREATING AN ASSEMBLY WITH TSQL As you have previously learned, an assembly is a unit of deployment in .NET. All .NET code is contained in an assembly. SQL Server projects, when compiled in Visual Studio, will compile into a DLL file. Registering an assembly in SQL Server is nothing more than copying the contents of that DLL file into the system catalog. .NET assemblies are very strongly versioned, and SQL Server will enforce a requirement that you cannot register the same assembly version in the database more than once. An assembly version is designated by four characteristics that the assembly programmer will control when he or she writes the code. You, as a consumer of the assembly, will not have any direct control over these characteristics, which are •u฀ Assembly name •u฀ Version number •u฀ Culture setting •u฀ Public key token

You will need to interact with the component developers to ensure they have followed a proper versioning standard and that the assembly in question has not been previously registered in the target database. Because the registration process copies the file content into the system catalog, it is not necessary for the assembly to be formally deployed on the target platform. The assembly from the previous exercises is ready for deployment.

1. To locate the assembly file, go back to the location in the file system where you created the Visual Studio project files. If you did not change any of the project settings, there should be a bin\debug path in that location where the assembly now resides. Make a note of this path or copy it to another more convenient location.

2. Register the assembly, using this code and replacing the assembly path in the example with the location of your assembly.

DEPLOYING MANAGED OBJECTS IN SQL SERVER

|

USE฀AdventureWorks2008; CREATE฀ASSEMBLY฀AWManagedCode FROM฀‘D:\AWManagedCode\bin\Debug\AWManagedCode.dll’; GO

At this point, you are free to add the stored procedures, functions, and any other managed objects that you may have created to SQL Server using the techniques that we will show you later in this chapter. Note that the previous pathname can also be replaced with a Universal Naming Convention (UNC) name, so the assembly file does not have to be local. It can be on any visible network resource as well.

CREATING AN ASSEMBLY WITH SQL SERVER MANAGEMENT STUDIO You can also drop and create the assembly with the Management Studio interface if you like. This is a very convenient option if there is no need for a script that you might have to maintain for process or versioning reasons.

1. To begin, connect the Object Explorer to the target server and drill into the database, to the Programmability node. In this node you will see an Assemblies node. This node contains all registered assemblies. If you can’t find this, look back to Figure 18.5 for an illustration.

2. If you have previously registered an assembly through TSQL, you may not see it in this list until you refresh the node. Right-click in the Assemblies node and select Refresh from the menu. If the assembly is registered, you should see it now.

3. To drop the assembly, right-click the assembly in the list and select Delete from the menu. This will open a dialog like the one pictured in Figure 18.6.

Figure 18.6 Dropping an assembly

557

558

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

In this image, notice the button labeled Show Dependencies. This is an important consideration. Every managed object is schema bound, which means that it is tied to the assembly. You cannot drop the assembly until you drop all the managed objects created from the assembly in the database. In our example, we had not yet added any managed objects from the assembly. This is why our previous script that dropped the assembly did a drop on all functions and procedures first before dropping the assembly itself.

4. To add the assembly again, right-click the Assemblies node in the Object Explorer and select New Assembly from the menu. This will present a dialog like the one illustrated in Figure 18.7.

5. Complete the dialog as illustrated, substituting the path with the location of your assembly. You should use the path of wherever your assembly file is currently located.

Figure 18.7 Registering an assembly

Notice in the dialog that in the dimmed properties section at the bottom, there is a property for the version number. It is currently set to 0. If we had explicitly versioned our assembly before we compiled it, this property would show the version number. There is also a property called Strong Name. This property refers to status of the strong name key for the assembly. To prevent tampering and to provide stronger versioning, a developer can compile a string name key into the assembly. If this is present, the public key token of that strong name key is part of the version data of the assembly. The assembly in this exercise is not strong named, so no token is present.

6. Click the OK button to commit this action and add the assembly to the database. You are now ready to add the managed objects within the assembly to the database catalog.

DEPLOYING MANAGED OBJECTS IN SQL SERVER

|

Creating Managed Objects Before you can call a managed object with TSQL code or from a client application, there must be something in the database catalog to call. Simply registering an assembly with the database doesn’t provide the catalog data necessary to call the objects stored in the assembly. We still have to create the catalog data for each element. The process is simple. We will use the appropriate data definition language statement to generate the object in the catalog. These statements have an option to point the catalog object to an external source instead of providing the code in TSQL. As an example, to add the CubeValue function to the catalog, you would use code like this. USE฀AdventureWorks2008; CREATE฀FUNCTION฀dbo.CubeValue ( ฀฀@value฀int ) RETURNS฀int AS EXTERNAL฀NAME฀[AWManagedCode].[UserDefinedFunctions].CubeValue; GO SELECT฀dbo.CubeValue(100); GO

This statement has all of the characteristics of a standard CREATE฀FUNCTION statement except that the reference to the assembly replaces the code of the function. The result is that whenever a user calls the function in SQL Server, as in the last statement in the snippet, it makes a call to the managed object instead of executing TSQL code. Notice that the external name of the function is broken into three parts. The first is the name of the assembly, followed by the fully qualified class name that contains the functions, including any namespaces, and finally the name of the function itself. The TVF is a little different, because the external name is the name of the Init method that represents the entry point to the function. Remember that every TVF requires both an Init method and a FillRow method. Although no specific name is required for these methods, you must know the name of the Init method because this will be required for creating the function in the catalog. Here is an example. USE฀AdventureWorks2008; CREATE฀FUNCTION฀dbo.PersonTable ( ฀฀@startID฀฀฀฀฀฀int, ฀฀@endID฀ ฀฀฀฀฀int ) RETURNS฀table฀฀ ( ฀฀FirstName฀nvarchar(100),฀ ฀฀LastName฀nvarchar(100) ) AS EXTERNAL฀NAME฀[AWManagedCode].[UserDefinedFunctions].InitPersonTable;

559

560

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

GO SELECT฀* FROM฀dbo.PersonTable(100,200); GO

Stored procedures follow the same basic pattern. You will use a standard data definition statement, replacing the TSQL code of the procedure with the external name of the procedure. This script adds and tests the two remaining procedural objects from the assembly to the database catalog. USE฀AdventureWorks2008; GO CREATE฀PROCEDURE฀dbo.GetPersonCount ( ฀฀@startID฀int, ฀฀@endID฀ int, ฀฀@count฀ int฀OUTPUT ) AS EXTERNAL฀NAME฀[AWManagedCode].[StoredProcedures].GetPersonCount; GO CREATE฀PROCEDURE฀dbo.GetPersonList ( ฀฀@startID฀฀฀฀฀฀int, ฀฀@endID฀ ฀฀฀฀฀int ) AS EXTERNAL฀NAME฀[AWManagedCode].[StoredProcedures].GetPersonList; GO DECLARE฀@vCount฀int; EXEC฀dbo.GetPersonCount฀100,200,@vCount฀OUTPUT; SELECT฀@vCount; EXEC฀dbo.GetPersonList฀100,200;

The user-defined types also follow the same pattern. This simple statement created the type in the target database. CREATE฀TYPE฀POINT EXTERNAL฀NAME฀[AWManagedCode].[Point];

You Can Be Selective As you can see from these examples, just because a registered assembly contains a managed object definition, it does not mean that the managed object is callable in your database. You can be selective. There may be times when all of the managed objects that ship with an assembly are not necessarily appropriate for your application, either from functionality or a security perspective. You only need to add the ones you need. Only someone with the authority to execute the data definition statement in the production database can create these managed objects in the catalog. As an administrator, if you control this permission, you will be able to control the managed objects in your database.

DEPLOYING MANAGED OBJECTS IN SQL SERVER

A Time and Place for Everything The need for managed objects in a database is specialized. Not every application or organization will use this feature, but for those that need it, it can be a life saver. This story about a scenario where managed objects fit well into the overall architecture is from the case files of Michael Lee. Creating effective application architecture is always full of trade-offs, but following general guidelines and best practices will often make the difference in the long-term health of an application. One of the architectural practices that you should try to be diligent in following is to divide application functionality into appropriate tiers. Using a general Model-View-Controller pattern as a guide—separating application functionality into data tiers, data access layers, business layers, and so forth—can significantly aid in maintenance by decoupling application components. In one situation, a consulting client had designed an architecture that did some order-processing by pulling orders that had been placed into a database and returning that data to a middle tier through a stored procedure. The process worked quite well until there was a change in the business that caused a modification to the way that the data was presented to the application. In the new model, there was a need to pull data from flat files as well as database tables to properly resolve the orders. The critical issue, however, was that the business tier could not be modified. Everything had to be done through a call to the same stored procedure, or at least a procedure with exactly the same name and parameter list. We evaluated a variety of approaches. The flat file data could be added to SQL Server tables through bulk inserts and then the stored procedure could be modified to use that data. We could have used a link to the data file and accessed the data in the stored procedure in that manner. For a variety of business reasons, the client rejected these options, leaving us with a quandary regarding how we could access file system resources as part of a data service. The answer was a managed stored procedure. We created a procedure in .NET that had the same parameter list as the original procedure. This managed code had the resources available to search for, open, and process the files necessary. The data was then correlated as needed to the data resident in SQL Server tables and a result set, which was equivalent in format as that previously returned by the stored procedure, was piped back to the business layer as before. Because the name of the procedure did not change, and neither did the parameter list or result set format, we were able to substitute the managed procedure directly in place of the TSQL procedure with no changes to the middle tier. We were also able to maintain the separation of business and data logic by not requiring a change to the business layer for processing of the flat file data, which is a data tier responsibility. While there are certainly other approaches that we could have used in this scenario, this one allowed us to achieve our business objectives without compromising our overall architecture.

|

561

562

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

Managing CLR Security There are two levels of security for managed objects. As an administrator, you have control over both user security and code access security. User Security User security refers to the standard security setup in SQL Server that allows you to control who can access and execute the managed objects that you add to the catalog. With just a few exceptions, this security process is essentially identical to the user security that was discussed in Chapter 8, “Managing User Security.” Code Access Security Code access security (CAS) relates to the permissions that assemblies have to access each other. For example, you may not want to enable a CLR assembly to have full unrestricted access to SQL Server and platform resources. Even with the best security design, a hacker could potentially exploit this weakness. Following the principle of least permissions, you should never authorize a user to do any more than is needed, and the same should go for the code. It makes no sense to allow an assembly to access platform resources that it does not need to do its work.

Managed Objects and User Security User security relates to what users can do with the artifacts. There are user security permissions for both the assemblies themselves and the managed objects contained in the assemblies. Once you create an assembly, you can assign user permissions to that assembly as illustrated in Figure 18.8. This allows selected users or roles to interact with the assemblies in specific ways, including taking ownership of the assembly, which gives that user all rights over the assembly.

Figure 18.8 Assembly permissions

MANAGING CLR SECURITY

|

This figure shows permission assignments in the visual interface, but you can also use standard GRANT, REVOKE, and DENY statements to control all permissions programmatically as well as in this statement. USE฀AdventureWorks2008; GRANT฀CONTROL฀ ON฀ASSEMBLY::AWManagedCode TO฀public; GO

Because the managed objects in the assemblies utilize standard data definiton code, they support the same user security described in Chapter 8. This includes the EXECUTE฀AS clause that allows the object to execute under the permission structure of any impersonated account or the account of the owner of the object. Please refer back to that chapter if you have any questions about this process.

Assemblies and Code Access Security If the managed object model has a weakness, it is that these objects can be too powerful if they are not properly controlled and secured. This is not a new issue. Extended stored procedures also suffered from the same problem, and if you have been around SQL Server for very long, you certainly have had experience in locking down extended stored procedures, specifically xp_cmdshell. Instead of an “all-or-nothing” model where the assembly is either enabled or disabled, the CLR integration model allows the assembly to run under three different security modes called permission sets. These permission sets state what level of access the assemblies will have to SQL Server and to the platform as a whole. While most assemblies will need very limited access to resources, occasionally there may be some requirements for more unrestricted access. The available permission sets are SAFE, EXTERNAL_ACCESS, and UNSAFE. SAFE This is the default permission set. When you do not specify any permission set as you create an assembly, it will assume this mode. In safe mode, the managed code is only allowed to do internal computations and data access to the local database resource. Most managed objects do not need access beyond safe mode; therefore, you should not modify the permission set unless the code requires additional resource access. EXTERNAL_ACCESS This mode allows access to local resources plus other external resources such as the file system, network resources, registry settings, environmental variables, and the event log. Because these resources could potentially be misused to compromise security and integrity, you must ensure that you tightly control permissions to these managed objects. Only an administrator can create an assembly with the permission set at the level of external access and above, and this permission cannot be granted to nonadministrator users. UNSAFE This is the most lenient permission set, and it extends the permissions the full trust level. There are no restrictions on what these assemblies can do, including interacting with services and managing environment options. You should use this permission set with extreme caution, and only when absolutely necessary. This level of access is rarely required and usually indicative of a design inconsistency.

563

564

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

Table 18.1 presents a summary of permission set features.

Table 18.1

Permission Set Summary SAFE

EXTERNAL _ ACCESS

UNSAFE

Code Access Security Permissions

Execute Only

Execute + External Access

External Access + Native Code

Programming Model Restrictions

Yes

Yes

None

Local Data Access

Yes

Yes

Yes

Ability to call Native (nonmanaged) code

No

No

Yes

You can set the permission set for your assembly either as you create the assembly in the database or afterward by altering the assembly. You can do this with either the Management Studio or using the TSQL code. As you can see in Figure 18.7, there is a dropdown list for “Permission set.” If you use the visual interface, you can set the permission set of the assembly using this dropdown list.

CONFIGURING THE DATABASE FOR EXTERNAL ACCESS If you tried to set your assembly for external access or unrestricted (unsafe) in the dialog, you probably received an error. This is because you must ensure that some preconditions are met before you will be able to make the permission set more liberal. This is a security measure to ensure adequate protection for all resources. One of two different conditions must exist before you can take this action. The first option is to mark the database as trustworthy. To do this, you must be an administrative user. Also, if you take this route, you must also be a dbo user when altering or creating the assembly. Consequently, the first condition is that you must be logged into the database as a valid dbo user. To mark the database as trustworthy, which means that the instance of SQL Server fully trusts the database and all of the objects inside the database, you will use the Trustworthy database property. To view the current setting for the Trustworthy property, use the Database Properties window as illustrated in Figure 18.9. Notice that the option is disabled by default. You cannot modify the property from here. To enable this option, use the following code. ALTER฀DATABASE฀AdventureWorks2008฀ SET฀TRUSTWORTHY฀ON;

MANAGING CLR SECURITY

|

Figure 18.9 Database properties

The other option, which is preferable, is to sign the assembly with an asymmetric key and give the key the appropriate level of permission. The key will ensure that the assembly is intact and has not been altered since it was registered, thus guaranteeing the integrity of the underlying codebase. This is a much more secure option than marking the database as trustworthy. The process requires the following steps.

1. Sign the assembly with a strong name key. 2. Generate an asymmetric key in SQL Server based on the contents of the assembly. 3. Create a login in SQL Server that maps to the asymmetric key. 4. Grant the new login external access or unsafe permissions as needed. 5. Register the new assembly with the permission set that matches the permission set granted to the login.

Lock It Down Even though it is very easy to mark the database as trustworthy and be done with it, we strongly recommend that you use a key-based approach. This approach to enabling increased access is significantly more secure. Because the code is signed and more tamper resistant, it also gives you an increased level of granularity. If you mark the database as trustworthy, any assembly in the database can be reset to a higher permission set. The key-based approach allows you to control the specific exposure at the assembly level.

565

566

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

The first step is to sign the original assembly. To do this, you will have to go back to Visual Studio. If your developers already have a key generated that they are using to sign their artifacts, you can use that one. Otherwise, you will need to generate a key. Visual Studio allows you to generate a key within the UI.

1. In the Visual Studio Solution Explorer, right-click on the project and select Properties from the menu.

2. From the tabs on the left of the dialog, select Signing. You should see a dialog like the one in Figure 18.10.

Figure 18.10 Signing the assembly

In this dialog, you can choose from a list of already registered key files, or you can browse for or create a new one. If you create a keyfile, you have the option of providing a password, which is recommended. This will help you secure the keyfile, which will represent your signature.

3. After setting the keyfile in this screen, save your project and build it. You must build it before the assembly will be strong named. To build the assembly, click Build  Build Solution from the menu.

4. The next step is to generate the asymmetric key. This process uses the strong name key used to sign the assembly and generates from that a key that it will store in the database. The asymmetric key must be created in the master database so that the server login can map to the key. You will then create the login and add the necessary permissions. Step 4 is implemented in the following code.

SECURITY CONSIDERATIONS

|

USE฀master; ฀ CREATE฀ASYMMETRIC฀KEY฀AWManagedKey฀FROM฀EXECUTABLE฀FILE฀=฀‘D:\CLR_Code\ AWManagedCode.dll’; CREATE฀LOGIN฀AWManagedLogin฀FROM฀ASYMMETRIC฀KEY฀AWManagedKey; GRANT฀EXTERNAL฀ACCESS฀ASSEMBLY฀TO฀AWManagedLogin; GO

Be sure that the path refers to the assembly that you just signed and not a location to which you copied the assembly at a previous step. Also, make sure that you set the appropriate permission to the login that represents your desired access level. They must match in order for this process to work.

5. The final step is to register the assembly in the database. If you registered this assembly before it was signed, you must drop the assembly and reregister it. This is because the signing of the assembly modifies the assembly metadata, and if you do not add the signed version to the assembly, the key data will not match. If the registered assembly has already been signed, then you can simple alter the permission set. If using the visual interface to register the assembly, use the Permission Set dropdown list to select the desired level of permissions. If you are using the TSQL code to create the assembly, the code will look like this. USE฀AdventureWorks2008; CREATE฀ASSEMBLY฀AWManagedCode FROM฀‘D:\CLR_Code\AWManagedCode.dll’ WITH฀PERMISSION_SET฀=฀EXTERNAL_ACCESS; GO

Security Considerations Most of the resistance that the CLR integration in SQL Server encounters relates to security. It is true that the CLR integration creates the opportunity for very powerful and potentially destructive artifacts, but if you manage your environment appropriately, you can mitigate this exposure significantly. The most important principle to follow is that of least privilege. We mentioned this earlier in this chapter, but it is very important to understand that the majority of the security exposures that cause problems are those when permissions and authority are granted without a requisite need. If you follow the principle of least privilege, you will be able to control much of your exposure. It is also very important that if you are going to elevate the permission set of an assembly beyond safe level, you should plan very carefully. Remember that when you give an assembly a permission set, it is granted to the entire assembly. If a particular functionality in a managed object will require a higher permission level, those features should be separated from those that do not need this level and packaged in their own assemblies. If you plan for security early, it will be easier to manage later. The most important advice that we can give is that you should not be afraid of this feature. The power that the CLR provides to your server can be significant, and when this power is properly harnessed, it can allow the server developer to do amazing things.

567

568

| CHAPTER 18

SQL SERVER AND THE COMMON LANGUAGE RUNTIME

The Bottom Line Enable and configure the CLR in SQL Server 2008. For security reasons, the CLR installs as a disabled feature and you must enable it before you will be able to create assemblies in your database. You can control this feature at the database level, and each database will host its own application domain, which gives you the ability to enable the CLR on some databases but not all databases in a SQL Server instance. Master It The CLR integration option is an advanced option that you can only set through code. The code to do this is very specific. Write the statements that you will use to enable this option. Create managed objects for the SQL Server CLR. Managed objects mimic standard TSQL objects in a database. Unlike standard procedural objects, however, the code for these managed objects is contained in a .NET assembly. You can create managed object in Visual Studio using any .NET-compliant programming language, including C# and VB.NET. Master It For each of the following situations, identify the attribute or code characteristic that you would use in Visual Studio to provide the needed functionality to a managed object.

1. You want to use ADO.NET code in a user-defined function. 2. You need to identify a method for a managed TVF to execute for each populated row in the returned table.

3. You need to execute a command and return the results back to the caller of a stored procedure. Master It Write a script that registers a managed assembly called Demo located at C:\demo.dll. The script should then add a function from the script called DemoFunction that takes no arguments and returns an integer. Assume that DemoFunction is in a class called UserDefinedFunctions. Manage security for the SQL Server CLR. Because these objects are very powerful, you must manage the security risk appropriately. You can implement user- and role-based security to control access to the managed objects. Additionally, you can use code access security through permission sets to ensure that the managed code is not allowed to execute actions outside of permitted and reasonable boundaries. Master It For each of the following situations, indicate whether you would use user security or code access security to achieve the desired result. Also, specify which object’s permissions must be modified and which permissions you should use.

1. An assembly called Demo contains a managed function called DemoFunction. You want to secure access to DemoFunction in the database.

2. An assembly called Demo contains a managed function called DemoFunction. Demo function performs database access to the local database.

3. An assembly called Demo contains a managed function called DemoFunction. This function accesses the file system.

4. An assembly called Demo contains a managed function called DemoFunction. You need to allow a backup administrator to take ownership if necessary.

Chapter 19

Using Spatial Data One of the new features of SQL Server 2008 is the support for spatial data. This exciting feature gives you the ability to store data representing positions and geometric structures natively in SQL Server. This can provide significant opportunities for data mining based on previously difficult metrics such as location, distance, and space. With the prevalence of spatially oriented applications and devices in our society—from cartographic applications to global positioning system (GPS) appliances—being able to store spatial data natively in SQL Server can simplify the data services that these systems require. SQL Server supports the current standards for spatial data storage and functionality; therefore, much of what you will see when dealing with spatial data might look a bit foreign at first, because it is not implemented using typical Microsoft patterns. However, once you become accustomed to the process, you should find spatial data simple to implement. In this chapter, you will learn to: •u฀ Define spatial storage in SQL Server •u฀ Implement geometry data •u฀ Implement geography data •u฀ Implement spatial indexes

Spatial Data Concepts The spatial datatypes in SQL Server adhere to the Open Geospatial Consortium (OGC) specification version 1.1.0. The goal of this standard is to provide a consistent way to describe and manipulate spatial and geospatial data to facilitate the integration of spatially oriented devices and applications. It sounds impressive, but it is really quite simple. You are simply describing where an entity is in your spatial universe, what its shape is, and how it relates to other objects around it. To get a better understanding of these concepts, consider some of the simple plane geometry that you have probably been exposed to in the past.

The Foundation Plane geometry is the description of shapes in two-dimensional space. Positions in this space are typically described using an ordered pair of numbers indicating their position on an axis. With this in mind, the diagram in Figure 19.1 should look familiar.

570

| CHAPTER 19

USING SPATIAL DATA

Figure 19.1 Identifying a point on a plane

(-3, 4)

(3, 1)

(2, -3)

The three points on the plane in this diagram are identified based on their X-coordinate positions (left and right) and their Y-coordinate positions (up and down). The X- and Y-values make up the ordered pair. Using this system, you can identify any point in two-dimensional space. Note that the diagram does not account for the units of the axes. The type of unit used is irrelevant. It does not matter if the units are meters, feet, or pixels. The math is the same. Any superimposition of units on the positioning system should happen in the business tier of an application and not at the database. In the database, this would be metadata at best, and irrelevant to most data-centric operations.

Things I Forgot from School Remember when you were in school and the geometry teacher was going on and on about diagramming figures on a plane? You most likely said to yourself, “When will I ever use this in the real world?” That day has come. The good news is that you do not have to remember all of the awful equations that Mr. Jones tried to teach you in geometry class. However, you might want to brush off the dust from that old geometry book in the closet, just in case. Don’t panic. We will keep it simple.

At first glance, this seems to be a very simplistic improvement. Storing a single point on a plane in a database doesn’t seem like a very big deal. But take a closer look and it is more complicated than it seems. There are two points in the ordered pair. How will you store these two points? Each number in the ordered pair represents a discrete value, but the two points are aggregated to provide an additional meaningful value. There are a number of ways that you could store this data. If you have ever tried to do this in a relational database, you know that it is not as simple as it sounds. You could store each value individually in the database. A table that contained data representing a point on a plane could have a column for the X-coordinate and a column for the Y-coordinate on that plane; however, technically this violates best practice because the smallest meaningful value is the pair, not the individual values in each pair. In contrast, you could store the pair in its own column. This would ensure that the pair is always together in a set, but what happens when you need to use the values in the pair for calculations? You would have to store the value as a string and parse the value to get any meaningful information.

SPATIAL DATA CONCEPTS

|

As the shapes get more complex, these problems become more complicated. Suppose the shape in question is a line instead of a point. Then you would need to have two ordered pairs of data representing the endpoints of the line. Continuing, the shape could be a polygon, which could have an unlimited number of points in the shape, which would be impractical to model at the data level. Additionally, suppose that you need to pass this spatial data as a parameter of a stored procedure or function, or you need to store it as a variable. It would be impractical to manage multiple sets of variables or use table variables just to manipulate a set of lines or polygons. The solution is to use the spatial data structures in SQL Server. These structures are implemented in SQL Server as managed .NET datatypes. They are not native SQL Server simple types, but rather they are complex types implemented in .NET code. Depending on the type of object you are describing, multiple values might need to be stored and manipulated. The managed type takes care of all of the redundant and standardized tasks, such as parsing string data representing the complex structure and storing that data into simple types. These managed types also handle all of the calculations that are common to the data in question, such as determining the length of a line or the distance between two points.

You Can Run, but You Can’t Hide from .NET If it suddenly seems as though .NET is everywhere in SQL Server and you can’t get away from it, there is some truth to that. In Chapter 18, “SQL Server and the Common Language Runtime,” we discussed how you can create your own .NET objects for SQL Server. The managed datatype is just one of those objects classes. If you need a refresher, refer back to Chapter 18. If you review the section on creating datatypes, the whole concept of spatial data will be easier to understand.

Geometry Versus Geography There are actually two spatial datatypes in SQL Server; they are the geometry type and the geography type. Although they do share many common characteristics, there are some differences between them. Each has its own specific purpose that is targeted to different kinds of applications. The geometry type stores data based on a flat-plane assumption. Every point is defined in two-dimensional space. All of the standard plane geometry you learned in school relates to the geometry datatype, as there is no curvature of space in this model. There is no assumption of a third dimension, so no solid masses, such as conic structures or other intersecting planes, intersect with the planes. The geography datatype describes an ellipsoidal Earth-mapping model. Contrary to common belief, Earth is not a ball; it is an ellipsoid, more like an egg. There is no actual fixed diameter measure for Earth, because taking the diameter measure at different points would return slightly different values. Because of this shape, a planar approach to position is inexact. The solution is to have a positioning system that can take this curvature into consideration. The classic measures of latitude and longitude are a perfect example of such a system. Although the distance between latitudes remains constant, longitudinal variances occur depending on how far north or south you are; the variances being greater at the equator and lesser at the poles.

571

572

| CHAPTER 19

USING SPATIAL DATA

The Earth Is Too Big to Cover Here Although discussing geography structure in depth and interacting with GPS data would certainly be interesting, they are far beyond the scope of this chapter. If you want to get into the standards and see how everything really works, visit the OGC website at http://www.opengeospatial.org. There you will find a wealth of information and fully documented geospatial standards. It is not easy reading, but it will be very worthwhile if you are going to go beyond the basics.

Both the geometry and geography datatypes support a variety of subtypes that represent specific shapes. You configure these shapes using a structure that the OGC calls Well-Known Text (WKT). WKT is simply a text-based format for describing the geometric shapes in question, usually using a set of ordered pairs, which the managed type then parses and manipulates.

Shapes Supported by Spatial Data The geometry and geography datatypes are abstractions for specific types of geometric shapes. To create a specific shape, you must provide the appropriate WKT format to the function that creates the type. The specific shapes are basically the same for the geometry and geography types; the only difference is whether the specific shape exists in a plane or ellipsoidal space. The specific shapes are •u฀ Point •u฀ MultiPoint •u฀ LineString •u฀ MultiLineString •u฀ Polygon •u฀ MultiPolygon •u฀ GeometryCollection

Each shape also has a corresponding collection version. You can store a single point, for example, in a Point type or an entire collection of points in the MultiPont type. The GeometryCollection type is an abstraction of these “multi” types that provides the collection behavior and aggregates the other specific types. The object model for these types is illustrated in Figure 19.2. Only the previously listed types are directly usable in SQL Server. All other types in this diagram are abstract and provide inherited structure only.

Terminology Clarification From now on, when we refer to the shapes, the specific meaning will depend on which general type we are referencing. For example, a LineString could exist on a plane if the context is geometry or an ellipsoidal surface if the context is geography. We will not take the time to distinguish between the two unless it is contextually necessary.

SPATIAL DATA CONCEPTS

Figure 19.2

|

Geometry

The spatial type hierarchy

Point

Curve

Surface

Line String

Polygon

Geometry Collection

MultiSurface MultiCurve MultiPoint

MultiPolygon

MultiLine String

Point The Point type represents a single one-dimensional reference identified by an ordered pair. You can use a single point as a position of reference or as an identifier to a single location on the surface. MultiPoint This represents a collection of zero or more points, usually representing a set of location identifiers. This is a collection object that can contain only points. You generate the type by using a WKT expression that represents all the points, not by adding points to the collection programmatically, which is the more typical Microsoft-based approach. LineString A LineString is a one-dimensional object consisting of two or more identifying points and their connecting line segments. Lines can be simple or complex. Figure 19.3 illustrates several LineString objects that, left to right, are simple, complex, and closed. Complex LineStrings have crossing points; closed figures use the same point to begin and end the shape.

Figure 19.3

Simple

Complex

Closed

LineStrings

MultiLineString This is a collection of LineString objects. Similar to the MultiPoint object, you create this collection by providing a WKT expression that identifies all the LineStrings in the collection. The contained LineStrings can be simple, intersecting, or closed. Using the different types of individual line strings, you can create a variety of structures. Figure 19.4 illustrates some of the options.

573

574

| CHAPTER 19

USING SPATIAL DATA

Figure 19.4

Simple

Intersecting

Closed

MultiLineStrings

Polygon A Polygon is a closed shape, referred to as a ring. The Polygon consists of a single ring that can have zero or more contained rings within it. The line segments that make up the rings of a Polygon can never intersect. Figure 19.5 illustrates both valid and invalid Polygon structures.

Figure 19.5

Valid

Valid

Invalid

Polygons

MultiPolygon This type represents a collection of valid Polygon shapes. If any one Polygon in the collection is invalid, then the entire collection is invalid. The outer ring of any polygon cannot intersect with any other outer ring or the entire collection is invalid. GeometryCollection While the previous collection types can store only objects of a specific type, the geometry collection can store multiple objects of various types. For example, you can store both a point and a polygon in a single GeometryCollection type. This gives you the flexibility to aggregate many shapes together.

Defining Spatial Storage Just as with simple datatypes, spatial types can be used in table definitions or as variable types. You can also set them as parameter types for functions and stored procedures and use them as return values for functions. Assume that you have a table that requires special data storage. Depending on whether you want planar or ellipsoidal manipulation, you can use either the geometry or geography datatype in much the same way that you would use a standard datatype. Consider the following table as an example. This code assumes that you have already created a sample database called Sandbox. USE฀Sandbox; CREATE฀TABLE฀dbo.Locations ( ฀฀LocationID฀฀฀฀int฀ PRIMARY฀KEY฀CLUSTERED, ฀฀LocationName฀฀nvarchar(30), ฀฀Position฀฀฀฀฀฀geometry );

IMPLEMENTING THE GEOMETRY TYPE

|

In this example, every position is recorded as a value using a geometry type. Notice that this code does not specify “Point” as the type. The table is unaware of the existence of the Point type. All spatial data will simply be stored as a geometry or geography type. This value will be identified as a Point, LineString, or Polygon when you store the value in the table.

The Contents Will Come Later Loading the data into the type is somewhat complex and we need to introduce the WKT format before it will be clear, so we will illustrate how to do it later in the chapter.

You can also use variables and parameters in the same way. Consider the following incomplete snippet from a function. You will see how spatial data plays an important role in process data as well. CREATE฀FUNCTION฀dbo.LocationInfo ( ฀฀@location฀ geometry )฀RETURNS฀int AS BEGIN ฀฀DECLARE฀@globalLocation฀฀geography; ฀฀—฀Remainder฀of฀function ฀฀return฀0; END;

This function does not do anything constructive, but from this illustration you should be able to see the mechanics of using both the geometry and geography฀types as parameters and variables. The important element of note here is not the striking difference between this and standard datatype implementation, but rather that the implementation is virtually identical.

Implementing the Geometry Type Now that you have seen the kinds of data that you can store into the geometry type and how to define the storage, you are ready to implement the type and load values accordingly. This process is a little bit different from what you are used to with standard types, but it does follow a standard formula, so it is easy to get comfortable with quickly. In this section, we will begin by learning how to load data into a geometry type based on the specific subtypes in question. Then we will look at how to manipulate that data using the methods associated with the .NET types.

Loading Geometry Data Because spatial data utilizes .NET managed types as opposed to simple SQL Server datatypes, loading values into a spatially typed table or variable is not as simple as assigning the value

575

576

| CHAPTER 19

USING SPATIAL DATA

directly. Instead, you will need to use methods associated with the spatial types to define this storage. The arguments that you provide to these methods are text-based and use a format defined by the OGC called Well-Known Text (WKT). Here is an example of using WKT to assign a point value at position (0,0) to a geometry variable. DECLARE฀@point฀geometry; SELECT฀@point฀=฀geometry::STGeomFromText(‘POINT฀(0฀0)’,฀0);

We Are Not Elevating This Discussion All shapes are created from points. These points can contain, in addition to the X- and Y-coordinates, a Z-value indicating elevation. Although the Z-value is storable, it is ignored in calculations and is, therefore, little more than metadata. All manipulations of spatial types are assumed to be based on just the X- and Y-values alone. For this reason, we will not discuss the Z-value in detail in this chapter. Additionally, you can include an M-value, which is a measure from a common point of reference. The M-value is used to provide positional context. These values are beyond our scope, but if you want to read more about the role of the Z- and M-values in the specification, please visit the OGC website at http://www.opengeospatial.org.

The STGeomFromText method is defined by the OGC and implemented by Microsoft as a member of the geometry datatype. The method has two arguments. The first is the WKT of the described geometric shape. The second argument is a Spatial Reference ID (SRID), which represents the identifier of the spatial reference system that you are using as a point of reference for your geographic data. This SRID will default to 0 for geometry types, and we will discuss the purpose of this value in greater detail when we address geography later in this chapter. Parse is an alternative method of storing a value into a geometry type. This method is equivalent to the STGeomFromText method except that it always assumes a SRID of 0, which is a safe assumption for the geometry type. The same operation using the Parse method would look like this: DECLARE฀@point฀geometry; SELECT฀@point฀=฀geometry::Parse(‘POINT฀(0฀0)’);

Using this approach, inserting data into the dbo.Locations table that was previously illustrated would look like this. Assume in all of these examples that you are using the Sandbox database. INSERT฀INTO฀dbo.Locations VALUES(1,’Origin’,฀geometry::Parse(‘POINT(0฀0)’));

Once inserted, the .NET code converts the text into a binary format representing the geometric object. This value is meaningless if you select it directly from a table, so you must use properties of the geometric typed value to extract the meaningful pieces of data that interest you. For

IMPLEMENTING THE GEOMETRY TYPE

|

example, suppose you want to return the X- and Y-coordinates of the point that was just inserted into the database. The code to do this would be as follows: SELECT ฀฀Position.STX฀as฀XCoordinate,฀ ฀฀Position.STY฀as฀YCoordinate FROM฀dbo.Locations;

Depending on the stored figure, there are a variety of different pieces of information that you can pull from the type such as areas, lengths, and endpoints.

Well-Known Binary SQL Server data is stored in a format called Well-Known Binary (WKB), which is a format defined by the OGC. The WKB format provides a viable storage format that can also be used to exchange data with other applications and data services that are WKB-compliant. Although this chapter focuses on creating spatial artifacts using the WKT format, SQL Server also supports the instantiation of all of these artifacts using WKB with OGC standard methods.

Working with Points and MultiPoints In the previous example, you saw how to store a point into a geometry type. The illustrated method used the generic methods STGeomFromText and Parse. You can use additional methods to create each type of geometric object, which will clarify the code significantly. To create a point directly at the origin of a matrix (position 0,0), you could use this code as well. DECLARE฀@point฀ geometry; SELECT฀@point฀=฀geometry::STPointFromText(‘POINT฀(0฀0)’,0);

Using this statement, the argument is verified to ensure that the WKT creates a point as opposed to any other geometric type. If the WKT represents any shape other than a point, the statement will fail. There are numerous methods for getting information about the points that you create. Some of those methods include: •u฀ STX: Returns the X-coordinate of a point •u฀ STY: Returns the Y-coordinate of a point •u฀ STDistance: Returns the shortest distance between two points •u฀ STEquals: Determines if two geometries are identical

For example, if you have two points in a grid and you want to find the distance between those two points, as shown in Figure 19.6. The following code will return the desired value.

577

578

| CHAPTER 19

USING SPATIAL DATA

Figure 19.6 Calculating distances (2, 1)

(-2, -2)

DECLARE฀@point1฀geometry; DECLARE฀@point2฀geometry; DECLARE฀@distance฀numeric(10,2); SELECT฀@point1฀=฀geometry::STPointFromText(‘POINT฀(2฀1)’,0); SELECT฀@point2฀=฀geometry::STPointFromText(‘POINT฀(-2฀-2)’,0); SELECT฀@distance฀=฀@point1.STDistance(@point2); SELECT฀@distance;

You can also store a collection of points in a MultiPoint object. If you want to store these two points into a single datum in SQL Server, the WKT format will require you to list all of the coordinates in order. Loading these two points would require code that looks like this: DECLARE฀@pointCollection฀geometry; SELECT฀@pointCollection฀=฀ ฀฀฀฀฀฀฀฀geometry::STMPointFromText(‘MULTIPOINT฀((2฀1),(-2฀-2))’,0);

To work with any individual point in the collection, you can access it using an index number based on the position in the collection using the STGeometryN method. This method returns an individual geometry element in a collection based on an index number. The following code returns the X-coordinate of the first point in the collection. SELECT฀@pointCollection.STGeometryN(1).STX;

You can also assign an individual element of the collection to a variable for further processing if you like. This example loads one of the points in the collection into a geometry instance, which is then queried to return its X-coordinate. SELECT฀@point฀=฀@pointCollection.STGeometryN(1); SELECT฀@point.STX;

IMPLEMENTING THE GEOMETRY TYPE

|

What’s the Point? Points are the basis for all geometry. As you will see later in this chapter, you can extract points from other geometric shapes and store those in point instances. Then, using these and other techniques, you can manipulate those points to get additional information about the geometries involved. If the concept of data mining based on geometry is suddenly leaping to the front of your mind, you are on the right track.

Working with LineStrings and MultiLineStrings In the strictest sense, the LineString does not exist in plane geometry. In geometry, a segment is the line fragment that exists between two points on a line. The line itself extends into infinity in both directions. In this sense, a line string is actually a set of connected segments. With the exception of the endpoints, each point in the LineString represents the beginning of one segment as well as the end of another. You might find it easier to think of the LineString in this way, as a set of segments. The WKT for a LineString is, therefore, nothing more than a set of points. The segments represent the shortest distance between each of these points in the order that they are provided in the WKT expression. A LineString, therefore, needs at least two points in its definition; it can contain additional points if additional segments are added to the structure. Refer to the diagram in Figure 19.7. This figure illustrates a LineString structure based on a set of two points. There is only one segment in this line string. Because you have already seen how the WKT syntax handles points, this should look very familiar. DECLARE฀@line฀geometry; SELECT฀@line฀=฀geometry::STLineFromText(‘LineString฀(-1฀-1,3฀2)’,0);

Figure 19.7 A LineString (3, 2)

(-1, -1)

You can add additional line segments to the LineString by adding pairs of values to the list of values in the WKT expression. The first and last point in the list will always be the endpoints of the LineString. If the first and last points in the list are the same, the shape is closed and represents a ring. Now that you have a valid line string, you can extract information about the shape

579

580

| CHAPTER 19

USING SPATIAL DATA

such as its endpoints and length. The following code returns the length of the LineString, which is the sum of the length of all segments. DECLARE฀@length฀numeric(10,2); SELECT฀@length฀=฀@line.STLength(); SELECT฀@length;

There are additional methods that you can use to get information about the LineStrings. The most common of these are STNumPoints: STPointN

Returns the number of points that comprise an instance

Returns a specific point in an instance

STPointOnSurface STStartPoint STEndPoint

Returns an arbitrary point that lies on an instance

Returns the start point of an instance Returns the end point of an instance

If you have more than one LineString instance, you can also use the geometry type to identify relationships between them, such as if they are disjoint or they intersect. Look at Figure 19.8, which illustrates two line strings. The code that follows the figure would identify to the developer that these two LineStrings intersect each other.

Figure 19.8 Intersecting LineStrings

(-1, 5) (1, 3) (-3, 2)

(-1, -1)

DECLARE฀@line1฀geometry; DECLARE฀@line2฀geometry; SELECT฀@line1฀=฀geometry::STLineFromText(‘LineString฀(-3฀2,1฀3)’,0); SELECT฀@line2฀=฀geometry::STLineFromText(‘LineString฀(-1฀5,-1฀-1)’,0); SELECT฀@line1.STIntersects(@line2);

The MultiLineString is similar in concept to the MultiPoint; it is merely a collection of LineStrings and the WKT expression will match that accordingly. Taking the two preceding LineString structures and loading them into a MultiLineString object would require code like this. Notice how you can interact directly with the elements of the collection. In this example, we determine the two instances. DECLARE฀@lineStringCollection฀geometry; SELECT฀@lineStringCollection฀=฀geometry::STMLineFromText(‘MultiLineString((-3฀2,1฀ 3),(-1฀5,-1฀-1))’,0); SELECT฀@lineStringCollection.STGeometryN(1).STEquals(@lineStringCollection. STGeometryN(2));

IMPLEMENTING THE GEOMETRY TYPE

|

The Path to Riches Because this is such new technology, we dug through some proof-of-concept code rather than production code for a case study. For an example of the things you can do with geometric data, consider this application that is current in design. The names and a few circumstances have been changed to protect the parties involved. The client is a retailer of specialty goods. This particular client has invested in technology to track the customer’s movement through their facility. The system tracks their customers’ interactions with various kiosks throughout the facility and each interaction is recorded. The facility has hundreds of these kiosks, and customers must interact with them to purchase the desired goods. Although customers do not have to identify themselves to interact with the kiosks, a series of rewards and promotions are offered to carded customers, so most of them choose to take this extra step. The application in question is a data-mining application that will track an individual customer’s movement throughout the facility. Each point of contact that the customer makes is a point in a matrix. From the start of their visit to the end, the set of points can be combined to form a LineString. Some of these LineStrings are simple, consisting of just a few segments. Others are very complex and often cross back on themselves. All of this geometric data is stored in a SQL Server 2008 database. Now comes the fun part. The important part of this application mines this data for patterns. We can ask numerous questions from the data, including: Which paths are the most common? Are there commonalities based on the number of points in the path? Where are the common intersection points of these paths? If we superimpose qualitative data onto these patterns, such as what kinds of products are available along the most common paths and intersections, then we can plan for better product placement. For example, if there are one or two points in the facility that everyone walks through, or if people who use certain paths through the facility end up spending larger amounts of money, we can place the best products along those paths to appeal to customers based on their demographics and buying habits. The proof of concept is beginning to show some fruit. What initially seemed like random flows through the facility are, in fact, patterns of behavior and that behavior can be predicted to a certain degree based on demographics. In an exercise like this, geometric data is not some abstract exercise. It is concrete and can be used to make very valuable business decisions. The moral of the story is that you should not immediately discount spatial data structures as “that stuff that the GPS developers use.” There is more to it than that, and you can use this kind of data to your advantage if you know how to manage it.

Working with Polygons and MultiPolygons The last basic shape in our set is the Polygon. A Polygon is a closed figure with zero or more closed figures inside. Similar to the LineString, the Polygon is made up of set points with segments connecting those points. Because it is a closed figure, the first point and the last point will always be the same. Because it must be a ring, the figure segments are not allowed to intersect with each other, a condition which is allowed with a LineString.

581

582

| CHAPTER 19

USING SPATIAL DATA

The WKT format for a Polygon is very similar to a LineString. The Polygon illustrated in Figure 19.9 is a simple shape with only an exterior ring. Note that the starting and ending points are the same, at position (3,-2) in the grid. The code that follows the figure creates the Polygon.

Figure 19.9

(4, 5)

A simple Polygon (-3, 3)

(-4, -2)

* (3, -2)

*Starting Point

DECLARE฀@polygon1฀geometry; SELECT฀@polygon1฀=฀geometry::STPolyFromText(‘POLYGON((3฀-2,4฀5,-3฀3,-4฀-2,฀3฀ -2))’,0);

Using a simple method called STArea, you can calculate the area of the polygon. The Polygon in Figure 19.9 has an area of 41 units, which can be determined by using this code: SELECT฀@polygon1.STArea();

If you like, you can also include one or more interior polygons inside the exterior shape. These interior Polygons are considered to be “holes” in the exterior shape. Therefore, they cannot overlap the exterior structure, although they can touch each other inside at a single point. Because these interior shapes are considered holes in the outer shape, their areas are deducted from the external shape when calculating an area on the Polygon as a whole. Consider the shape in Figure 19.10. The external shape is identical to the one pictured in Figure 19.9, but this one contains an internal Polygon as well. It follows all of the rules in that it does not intersect with the external shape at any point. The code following the figure illustrates how to create this shape as well as how to calculate the entire figure. DECLARE฀@polygon1฀geometry; SELECT฀@polygon1฀=฀geometry::STPolyFromText(‘POLYGON((3฀-2,4฀5,-3฀3,-4฀-2,฀3฀-2),(2฀ 2,-1฀-1,2฀-1,2฀2))’,0); SELECT฀@polygon1.STArea();

The area of this figure is 36.5 units, which is the total area of the figure less the area of the internal figure. If you want these figures to be separate overlapping figures as opposed to a single figure with a hole, you must use separate Polygon shapes for each figure. You cannot use a MultiPolygon type to store the entire set because the MultiPolygon shape requires that the elements do not overlap. They are allowed to touch only at a single point.

IMPLEMENTING THE GEOMETRY TYPE

Figure 19.10 A Polygon with an interior ring

|

(4, 5) (-3, 3) *

(-1, -1)

(-4, -2)

(2, 2)

(2, -1)

* (3, -2)

*Starting Point

If you do have separate Polygon instances for each shape, you can get other interesting information about those shapes as well as the total area of each shape. Consider the following code that stores each of the shapes in Figure 19.10 as a separate object. DECLARE฀@polygon1฀geometry; DECLARE฀@polygon2฀geometry; SELECT฀@polygon1฀=฀geometry::STPolyFromText(‘POLYGON((3฀-2,4฀5,-3฀3,-4฀-2,฀3฀ -2))’,0); SELECT฀@polygon2฀=฀geometry::STPolyFromText(‘POLYGON((2฀2,-1฀-1,2฀-1,2฀2))’,0); SELECT฀@polygon1.STArea(); SELECT฀@polygon2.STArea(); SELECT฀@polygon2.STOverlaps(@polygon1); SELECT฀@polygon2.STWithin(@polygon1);

The preceding code gives you the individual area of each shape. You can easily add the individual areas together to give you a total area for both figures. The code also determines if the figures overlap or if one figure is entirely within another. This could be very important information if you are determining whether or not these figures could be loaded into a MultiPolygon collection or could be used to create a single Polygon with a hole. The MultiPolygon shape can contain multiple Polygons. Because each of these Polygons can also have holes, the resulting WKT expression can be very complicated. The WKT convention is very deliberate in its use of parentheses to keep things organized. The following code creates a MultiPolygon shape. The first Polygon in the collection is the figure pictured in Figure 19.10 with the hole. The second is another nonintersecting shape with no hole. Pay close attention to the parentheses as you evaluate this syntax. DECLARE฀@mpolygon1฀geometry; DECLARE฀@area฀numeric(10,2); SELECT฀@mpolygon1฀=฀geometry::STMPolyFromText(‘MULTIPOLYGON(((3฀-2,4฀5,-3฀3,-4฀-2,฀ 3฀-2),(2฀2,-1฀-1,2฀-1,2฀2)),((5฀5,10฀5,5฀10,5฀5)))’,0); SELECT฀@area฀=฀@mpolygon1.STGeometryN(1).STArea()฀+฀@mpolygon1.STGeometryN(2). STArea(); SELECT฀@area;

583

584

| CHAPTER 19

USING SPATIAL DATA

You can also compare objects of different types. One very useful technique is to use the STContains method to see if a Polygon contains another object such as a LineString or a Point. This is useful in determining if one figure is a component of another figure. Also, the STWithin method previously illustrated is very convenient in determining if a point of reference is within the boundaries of a Polygon.

Using the GeometryCollection Unlike the other collections, such as MultiPoint and MultiPolygon, the GeometryCollection does not require all members of the collection to be of a specific type. This can be very convenient when you want to aggregate elements of varying types into one structure, which can then be stored or passed as a single element. To create a GeomtryCollection object, you must have elements to place within it. Assume that you wanted to store a point at (4,5) and a LineString from (-3,4) to (3,2) in the same collection. You could use a GeometryCollection with code like this: DECLARE฀@geomColl฀geometry; SELECT฀@geomColl฀=฀geometry::STGeomCollFromText(‘GEOMETRYCOLLECTION(POINT(4฀ 5),LineString(-3฀4,3฀2))’,0);

Remember that the GeometryCollection type is actually the base type for all of the other “Multi” types in the model, which means that this type has less functionality than the other types because it is less specific. What it loses in functionality, however, it gains in flexibility. The GeometryCollection can aggregate shapes together in much the same way as you can pass tablevalued parameters in SQL code, allowing you to aggregate larger amounts of data together in a single parameter.

Implementing the Geography Type Unlike the geometry type, which exists only in a two-dimensional plane, the geography type is earthbound in an ellipsoidal projection. The geography type is used more frequently for GPS or cartographic applications, especially those that are more macro-oriented where Earth’s curvature might have an overall impact on application implementations. Although the geography type is almost identical in implementation to the geometry type, there are a few important differences. In this section, you will learn about the role of the Spatial Reference ID in geography and then overview the differences between the geometry and geography implementations.

Understanding the Spatial Reference Those of you who have worked with GPS applications or who have advanced degrees in geography or cartography have seen this concept before. The essence of the SRID is that, unlike a grid where we can agree on a universal point of reference at position (0,0), earthbound applications are a little different. We must all have a common point of reference. In school you probably learned that the standard point of reference is the prime meridian, which runs through Greenwich, UK. However, the truth is that many different reference points are in common use today. If we are going to compare metrics from one application to another, or even one observation to another, those metrics are meaningless if they do not use the same point of reference. This is where the SRID comes in.

IMPLEMENTING THE GEOGRAPHY TYPE

|

The SRID is nothing more than an integer that uniquely defines a system of reference. You have many options for the standard point of reference you use, and different kinds of applications ranging from GPS to mapping systems might use different references depending on the application, industry, or even national origin. One of the important distinctions between geometry and geography types is that geography data requires a SRID. Geometry types default to 0 because a geometric shape can exist in an undefined planar space, but a geography type cannot. SQL Server used a default SRID of 4326, which maps to the World Geodetic System (WGS) 84 spatial reference system. If you want to use any other reference system, you must provide the SRID when you create your geography type.

Getting a Valid SRID The SRID that you use must be a valid, defined reference ID and it must also be in the list of reference ID values defined in the SQL Server system catalog. The sys.spatial_reference_systems catalog view contains brief descriptions of the valid reference ID values that SQL Server recognizes. You may want to browse through this list to get an idea of the options available and their relevance to your applications.

If you want to create a geographic entity, the code is essentially the same as the geometry type. The difference is that the point of origin is determined by the SRID. Note that the SRID also indicates the units of measure, which is usually meters, but not always. Therefore, the meaning of any geographic value is entirely dependent on the SRID used when you create the shape. Consider these four lines of code: DECLARE฀@geog1฀geography; DECLARE฀@geog2฀geography; SELECT฀@geog1฀=฀geography::STPointFromText(‘POINT(1฀1)’,4326); SELECT฀@geog2฀=฀geography::Parse(‘POINT(1฀1)’);

Based on the defaults for the SRID in SQL Server, these two variables would store the same position based on the same point of reference and are, therefore, comparable data. If you were to execute this statement now, it would indicate that the two Points were equal by returning the value of 1. SELECT฀@geog1.STEquals(@geog2);

If you were to modify one of the points to identify a position other than (1,1), the previous statement would return 0, indicating that the two Points are not equal. If these Points were not using the same SRID, the result would be very different. Consider this code as an example: DECLARE฀@geog1฀geography; DECLARE฀@geog2฀geography; SELECT฀@geog1฀=฀geography::STPointFromText(‘POINT(1฀1)’,4326); SELECT฀@geog2฀=฀geography::STPointFromText(‘POINT(1฀1)’,4120); SELECT฀@geog1.STEquals(@geog2);

585

586

| CHAPTER 19

USING SPATIAL DATA

In this case, the two points are using a different point of reference because the SRID values are different. This means that the data is not comparable in any way. Any comparison of these values would be meaningless. Our result for the STEquals is, therefore, also meaningless. Executing this code would result in a selected value of NULL. It cannot return either 0 or 1, as it cannot determine at all if these positions are equivalent or not. Be sure that you keep this in mind if you work with geographic data. You must choose and be consistent with a single point of reference.

Geometry Versus Geography As we previously mentioned, the geometry and geography types are almost identical in terms of their functionality. The concepts are essentially the same; the basic patterns that you learned with the geometry datatype also apply to the geography datatype. The primary differences lie in their internal implementations and not their external interface. That said, there are a few areas where they are distinctly different and these are worth addressing. The SRID Requirement The geometry type can use an SRID if it is relevant, but using it is not required. If you do not provide an SRID for the geometry type, it will default to 0, which represents undefined planar space. The geography type requires an SRID and 0 is not a valid value. The default of 4326 can be overridden in your code, but any shapes are comparable only if they have the same SRID. Polygon Instances Because the geography type is a round-Earth model, there are restrictions to the size and structure of shape instances. A Polygon, for example, is restricted to exist within a single hemisphere. Also, point order in geography is strictly enforced. When creating Polygons, all points must be listed counter-clockwise. Methods Numerous methods are supported by geometry that are not supported by the geography type. These methods are those that handle objects that exist only in flat planar space. These include but are not limited to: •u฀ STTouches •u฀ STOverlaps •u฀ STCrosses •u฀ STWithin •u฀ STContains •u฀ STRelate

There are also some methods that do essentially the same thing in geography and geometry, but they are named differently because the implementation between planar and ellipsoidal space is so different. For example, the STDistance method of the geometry type is replaced by the STDifference method for the geography type. This is logical if you think about what the methods do. STDistance will determine the shortest distance between two points. In the case of planar space that is just fine, but in a round-earth space the shortest distance could slice right through the center of the Earth! The

SPATIAL INDEXES

|

information might be useful, but not if you are trying to calculate the distance you would have to travel on the surface of the Earth to go from one point to another. The STDifference method requires that travel occur across the surface of the Earth, instead of taking a shortcut through the Earth’s core. Again, for the most part, the geography and geometry types are the same in practice, so all of the code you used to create instances and load collections will be the same, the only substantive difference being the use of an appropriate SRID.

Spatial Indexes Whenever you store data in SQL Server, you have to be able to extract that information efficiently. With spatial data, however, traditional indexes will not work. This is because the values that you must index are stored within the WKB data, and they are often stored deep within that data. In this regard, these spatial indexes are very similar in concept to XML indexes, where traditional column-based indexes provide no practical benefit. To understand the need for spatial indexing, consider the following code. Notice how the WHERE clause in the final query does not follow a pattern that can benefit from a traditional index due to the lack of a search argument. USE฀Sandbox; CREATE฀TABLE฀dbo.Locations ( ฀฀LocationID฀฀฀฀int฀ PRIMARY฀KEY฀CLUSTERED, ฀฀LocationName฀฀nvarchar(30), ฀฀Position฀฀฀฀฀฀geometry ); INSERT฀INTO฀dbo.Locations VALUES฀(1,฀‘origin’,฀geometry::STPointFromText(‘POINT(0฀0)’,0)); INSERT฀INTO฀dbo.Locations VALUES฀(2,฀‘point1’,฀geometry::STPointFromText(‘POINT(1฀1)’,0)); INSERT฀INTO฀dbo.Locations VALUES฀(3,฀‘point2’,฀geometry::STPointFromText(‘POINT(-5฀-5)’,0)); GO DECLARE฀@polygon฀geometry; SELECT฀@polygon฀=฀geometry::STPolyFromText(‘POLYGON((2฀2,฀-2฀2,฀-2฀-2,฀2฀-2,฀2฀ 2))’,0);

587

588

| CHAPTER 19

USING SPATIAL DATA

SELECT฀* FROM฀dbo.Locations WHERE฀Position.STWithin(@polygon)฀=฀1; GO

This query should only return the origin and point1 as valid responses. Point2 is outside of the Polygon and, therefore, does not return. However, the only way to determine this fact would be to evaluate every point in the table. If you have a very large table with numerous points, this would be impractical. A standard search argument in a query requires that the column be isolated on one side of the comparison with an expression on the other side. This is not possible in this case because you are querying based on geometric relationships, not data-based relationships. The solution is to create a spatial index on the Position column in the table that the expression can use to better search through the matching data.

Spatial Index Architecture and Restrictions Spatial indexes are organized as b-tree structures in SQL Server, so when yore create an index, SQL Server must convert the data from a spatial structure in a grid to a linear tree-based structure. It does this by determining which points exist in which cells in the grid and using this information to create the index of grid locations. You have the option of controlling the granularity of the grid. For example, if you use an index that breaks the geometry into only a few grid spaces, your index will consume less space but will be useful, because more points will exist in the same cells in the grid. For example, if you have 20 points and they are spread over a 2 × 2 grid with four cells, there will be an average of five points per cell. If the index determines that the query is requesting a point from that cell, it must evaluate all five points. By contrast, if the grid is a 4 × 4 grid with 16 cells, the density of points per cell will decrease, meaning a large index but a smaller point density. You must decide where this trade-off makes the most sense for you as you design your indexes. Table 19.1 provides a listing of your options. If you do not specify a grid structure to overlay your index, SQL Server will assume a medium level of density.

Table 19.1

Spatial Index Grid Structures

Keyword

Grid Structure

Number of Cells

LOW

4x4

16

MEDIUM

8x8

64

HIGH

16 x 16

256

SPATIAL INDEXES

|

By default, the index is divided into four levels in the tree structure. You can select a grid configuration for each of the four levels in the index. This allows you to aggregate at a lower density at one level but increase the density at another level. To keep the system from indexing empty space in a grid, you also use what is called a bounding box. This is a set of X,Y-coordinates that represents the boundaries of the indexed space.

Avoiding the Details If you really want to know all of the internals on how spatial indexes work and the algorithms they use, you can read the details in the SQL Server Books Online. Because the details are readily available there, we will not repeat them here. The grid density is the only thing that you can control, so it is the only concept you really need to understand now. However, if you want to get the most from spatial indexes, a little extra reading will be worth the time. Understanding how the indexes work will help you structure your queries and select the right granularity for your indexes.

Just as with XML indexes, there are some restrictions on spatial indexes. If you attempt to create a spatial index without following the rules, the process will fail. The important restrictions are •u฀ You can create spatial indexes only on spatial columns of type geometry or geography. •u฀ You cannot create a spatial index on a parameter or variable. •u฀ Every table that has spatial indexes must have a Primary Key constraint defined. •u฀ A composite primary key cannot contain more than 15 columns. •u฀ The total length of all columns in a composite key cannot exceed 895 bytes. •u฀ Once you define a spatial index on a table, you cannot modify the primary key unless you

drop the spatial index.

Creating Spatial Indexes If you can create a regular index, spatial indexes will look very familiar. You can create them by using the SQL Server Management Studio (SSMS) interface or by using Transact-SQL (TSQL) code. Either approach will yield the same result. To use SSMS, open the studio interface and connect the Explorer to the service instance that contains the target database. Expand the database node of the target database. Locate and expand the tables node. In the list of tables, locate the table that contains the spatial data column. Expand this node and locate the indexes node. To create the index, right-click the indexes node and select New Index from the menu. This will open the dialog pictured in Figure 19.11. This figure shows the complete dialog. To add a column to the spatial index, click the Add button and select the column from the list that appears. Remember that you will only be able to select columns that are typed as spatial data. If you click the Spatial page selector on the left of the dialog, a dialog like the one pictured in Figure 19.12 will appear.

589

590

| CHAPTER 19

USING SPATIAL DATA

Figure 19.11 Creating a spatial index

Figure 19.12 Setting the spatial properties

SPATIAL INDEXES

|

This dialog allows you to control the grid granularity and specify the configuration of the bounding box. You can also adjust the indexing algorithm, known as tessellation, to use either a geometric or geographic scheme.

What Is Tessellation? Tessellation is a fancy word meaning the arrangement of shapes into a pattern. When you were three years old and were arranging your blocks on the kitchen floor, you were practicing the art of tessellation. In the context of spatial data, the concept is that a plane and an ellipsoid are two very different surfaces, so the algorithms used to place objects on the surface to locate them again later will be very different. Make sure that the Tessellation setting for your index matches the datatype upon which the index is built.

You can also create this index using TSQL code. An example is listed here. Note the similarity to standard indexes. USE฀Sandbox; CREATE฀SPATIAL฀INDEX฀idx_Position ฀฀ON฀dbo.Locations(Position) ฀฀USING฀GEOMETRY_GRID ฀฀WITH฀( ฀฀BOUNDING_BOX฀=฀(฀xmin=0,฀ymin=0,฀xmax=10,฀ymax=10฀), ฀฀GRIDS฀=฀(LOW,฀MEDIUM,฀MEDIUM,฀HIGH), ฀฀CELLS_PER_OBJECT฀=฀64);

You should be able to compare this code to the SSMS dialogs in the previous two figures. This code generates and index called idx_Position on the Position column of the dbo.Locations table. The USING฀GEOMETRY_GRID statement identifies the tessellation algorithm that the index will use. Note how the WITH block also identifies the special values, such as the bounding box and the level granularity. Although spatial indexes are useful, not all methods will take advantage of them. For the geometry datatype, the spatial indexes are used by these methods in the following forms. Note that you cannot invert the form and put the result before the method or it will return false positives. •u฀ geometry1 . STContains ( geometry2 ) = 1 •u฀ geometry1 . STDistance ( geometry2 ) < number •u฀ geometry1 . STDistance ( geometry2 )