In May, I'll be in the US. I have board meetings for PASS at the SQLRally event in Dallas, and then I'm going to be spending a bit of time in Chicago.
The big news is that while I'm in Chicago (May 14-16), I'm going to teach my "Advanced T-SQL Querying and Reporting: Building Effectiveness" course. This is a course that I've been teaching since the 2005 days, and have modified over time for 2008 and 2012. It's very much my most popular course, and I love teaching it. Let me tell you why.
For years, I wrote queries and thought I was good at it. I was a developer. I'd written a lot of C (and other, more fun languages like Prolog and Lisp) at university, and then got into the 'real world' and coded in VB, PL/SQL, and so on through to C#, and saw SQL (whichever database system it was) as just a way of getting the data back. I could write a query to return just about whatever data I wanted, and that was good. I was better at it than the people around me, and that helped. (It didn't help my progression into management, then it just became a frustration, but for the most part, it was good to know that I was good at this particular thing.)
But then I discovered the other side of querying – the execution plan. I started to learn about the translation from what I'd written into the plan, and this impacted my query-writing significantly. I look back at the queries I wrote before I understood this, and shudder. I wrote queries that were correct, but often a long way from effective. I'd done query tuning, but had largely done it without considering the plan, just inferring what indexes would help.
This is not a performance-tuning course. It's focused on the T-SQL that you read and write. But performance is a significant and recurring theme. Effective T-SQL has to be about performance – it's the biggest way that a query becomes effective. There are other aspects too though – such as using constructs better. For example – I can write code that modifies data nicely, but if I haven't learned about the MERGE statement and the way that it can impact things, I'm missing a few tricks.
If you're going to do this course, a good place to be is the situation I was in a few years before I wrote this course. You're probably comfortable with writing T-SQL queries. You know how to make a SELECT statement do what you need it to, but feel there has to be a better way. You can write JOINs easily, and understand how to use LEFT JOIN to make sure you don't filter out rows from the first table, but you're coding blind.
The first module I cover is on Query Execution. Take a look at the Course Outline at Data Education's website. The first part of the first module is on the components of a SELECT statement (where I make you think harder about GROUP BY than you probably have before), but then we jump straight into Execution Plans. Some stuff on indexes is in there too, as is simplification and SARGability. Some of this is stuff that you may have heard me present on at conferences, but here you have me for three days straight. I'm sure you can imagine that we revisit these topics throughout the rest of the course as well, and you'd be right. In the second and third modules we look at a bunch of other aspects, including some of the T-SQL constructs that lots of people don't know, and various other things that can help your T-SQL be, well, more effective.
I've had quite a lot of people do this course and be itching to get back to work even on the first day. That's not a comment about the jokes I tell, but because people want to look at the queries they run.
LobsterPot Solutions is thrilled to be partnering with Data Education to bring this training to Chicago. Visit their website to register for the course.