I’ve put in several abstracts for the 2011 Summit. This year we’re voting for preferred sessions. If you’re interested in any of the ones I’ve listed below, please consider giving me a vote.I was very kindly invited to submit for a spotlight session (for which I am very grateful and humbled, again) so I put two in for that. I also put in for two regular sessions. This year, for the first time I put in not one, but two abstracts for all day pre/post-conference sessions. One of them was put together as a partnership between Gail Shaw (blog|twitter) and myself. I’m excited by that one.
I love speaking and I really hope I make the cut.
In the interest of sharing, these are the abstracts I’ve submitted:
Spotlight: DMOs as a Shortcut for Performance Tuning
Dynamic Management Objects(DMO) expose a wealth of information to the database administrator. However, they also expose information that is vital to the database developer. More often than not people gather performance metrics through server side traces, but they don’t have to. This session will show how to gather information from the DMOs for currently executing, and recently executed queries. The session will demonstrate combining this information with other DMOs to get more interesting information such as the query plan and query text. I’ll show where you can get aggregate information for the queries in cache to determine which queries are being frequently accessed or using the most resources. I’ll show how to determine which indexes are being used in your system and which are not. All of this will be focused, not on the DBA, but on the query writer, the developer or database developer that needs information to tune and troubleshoot data access.
Spotlight: Reading An Execution Plan
This presentation will be about execution plans and nothing but execution plans. I will spend the entire session showing you as much as possible about all the information available to you inside execution plans. I’ll show you how to dig into the plans to gather all the data there that tells you what happened with your query. We’ll go to places in the plans that people just don’t think to look at and explore how information from these places informs you about the operations and methods of the optimizer and the storage engine. From this session I want you to learn how to read a plan for yourself. Once that’s in hand, you’ll never need anyone’s help tuning a query again.
Session: SQL Server Backup and Restore for the Accidental DBA
You’ve either volunteered or had the position thrust upon you, but here you are. You’re the DBA. You are being looked to as the person who will protect the companies’ data and you really don’t have a clue where to start. Let me suggest that one of the first things you should do is put together a good plan for backing up your database. This session will focus on the best practices, standards and methods that you can employ to ensure that you have a solid backup process for the databases under your charge. You’ll also learn how to restore these databases, because your backups are only good if you can restore them. We’ll also go over some of the questions you should be asking your business, because data recovery is as much a business decision as a technical one. At the end of the session, you should be able to go back to your office with confidence that you can begin to protect your data.
Session: Creating a Winning Abstract
You’ve decided that you’d like to try out this technical presentation thing, but you’re expected to write this odd little document called an abstract. What the heck is an abstract? This session will attempt to answer that question. It will also provide some methods and best practices for improving your abstracts and possibly improving your chances of getting selected. I’ll be working from failed and accepted abstracts of my own and examples from others, again, both failed and accepted. We’ll talk about what makes an abstract work and what makes an abstract ugly. You’ll be able to take home a few new ideas for building abstracts of your own that can help to get you started making presentations at your local user group, SQL Saturday, and possibly even international events like the PASS Summit. (and yes, if this one doesn’t get selected, it’s the last time I submit it, anywhere, ever)
PreCon: SQL Server Query Performance Tuning: Start to Finish
One of the most common problems encountered in SQL Server is the slow running query. Once a query is identified as running poorly, people frequently don’t understand how to diagnose and fix the problem. This one day seminar focuses exclusively on these two topics, identifying the queries that are performing badly and figuring out how to fix them. We start by learning how to gather performance metrics including both server metrics and query metrics using tools available directly from Microsoft such as performance monitor, DMOs and Profiler. From there we’ll move into learning how the optimizer works and how it uses statistics to determine which indexes and other database objects can be used to assist the performance of a query. The session takes considerable time to show exactly how to generate and read execution plans, the one best mechanism for observing how the optimizer works. We’ll then look at other DMOs that can also assist you when performance tuning queries. With all this knowledge gathered, we’ll move into looking at common performance problems, how they evidence themselves in the metrics and execution plans, and how to address them. Finally, we’ll explore advanced methods for solving some of the more difficult query performance problems introducing such concepts as query hints, plan guides and plan forcing. Through all of this, best practices and common techniques will be reviewed. Attendees will go home with a working knowledge of query performance tuning, a set of methods for identifying poorly performing queries, scripts to assist in these processes and the knowledge of how to fix performance problems in their own systems.
PreCon: All About Execution Plans
The key to understanding how SQL Server is processing your queries is the execution plan. This full day session focuses on the execution plan. We will start right at the beginning and talk about the compile process. We’ll also go over how, and more importantly, why, plans are stored in cache and how they are removed. We’ll spend time exploring the key differences between actual and estimated plans, and why those descriptions are more than a little misleading. We’ll also show you assorted methods to obtain a query’s execution plan and what the differences and tradeoffs of each are. A full day class on execution plans would not be complete without spending time learning to reading them. You’ll learn where to find useful information in execution plans, what the common operators are and how to decipher the sometimes cryptic messages the plans are sending to you. We’ll also debunk some myths surrounding query operators and execution plans. All of this is meant to further your understanding of how queries work in order to improve the queries you’re responsible for. With this in mind, we’ll show how you can use execution plans to tune queries. All of the information presented will be taken from real world examples. We’ll build on the information through the day so that at the end, after following us through multiple examples at your own computer, you’ll have a stronger understanding of how to read, interpret and actually use execution plans in your day-to-day job.