Another week has flown by and it is Tuesday again. And with that I really should not delay writing the T-SQL Tuesday round-up any longer. So here it is:
Thank you everybody who took the time to participate in this great party. I also want to thank Adam Machanic (B|T) for inventing T-SQL Tuesday and for letting me host this month.
Below is the list of all participating posts that I was able to find. Please let me know if I missed anything.
Rob Farley (B|T) writes about joins that we usually don't think about when writing queries because they happen without the JOIN key word being used. They are those implicit joins that SQL Server has to execute to get the data together if a single index is not enough.
Koen Verbeeck (B|T) reminds us of the long forgotten old style join syntax that Oracle queries used to feature. They used WHERE col1 (+) = col2 as right outer join equivalent. Make sure to read Rob Farley's comment to this post too.
Jeffrey Verheul (a.k.a. DevJef) (B|T) reviewed a merge statement written by a college that not only wasted unnecessary CPU cycles by copying data into a table variable without using it afterwards, but worse also updated more rows than intended.
Steve Jones (B|T) writes about the importance of readable code. This is one of my personal pet-peeves too. We spend a lot more time maintaining code than writing it in the first place. If the code we have to maintain would be readable all our lives would be so much simpler.
Matt Velic (B|T) reminds us that queries do not always have to use the key word JOIN for SQL Server to select a Join operator.
Rick Krueger (B|T) reaffirms how important it is to include the complete join condition in the ON clause. While you might get it to work otherwise you will more likely end up with buggy code.
Ted Krueger (B|T) shows us how to use the power of joins to qualify the rows to change in an UPDATE statement.
Alan Dykes (B|G) explains how you can use an outer self-join to identify gaps in a sequence of age ranges.
Ami Levin (B|T) gives us a quick overview of the strength and weaknesses of the three physical join operators.
Mickey Stuewe (B|T) shows an example of a nested reversed join creating a readability roadblock. Mickey also shows how to rewrite it into a straight and easy to follow join line. — My comment: join zen.
Jason E Bacani (B|T) gives a few suggestions of how to format joins.
Thomas Rushton (B|T) reminds us that SARGability is a very important concept and applies not only to WHERE clauses.
Valentino Vranken (B|T) introduces the Join() and Split() functions in SSRS.
Mike Decuir (B|T) takes a simple join query and shows us how much work it would be to implement that functionality in other programming languages. He is giving examples in Python, Powershell, Pig and R.
Jason Brimhall (B|G) gives a long list of different options to write a join against two tables that do not necessarily match on the join column. He ends in a short paragraph about implicit conversions.
Wayne Sheffield (B|T) picks up the implicit conversion topic and shows just how much havoc it can wreak on your queries.
Tamera Michelle Clark (B|T) took a survey at her work place to find out if people when joining others at the table during the holiday season would prefer a left or a right join approach.
Chris Yates (B|T) gives a brief refresher on the join topic in general based on queries he has seen in the wild.
This is my own contribution to this T-SQL Tuesday. In this article I am showing how to use the "0-1-some" heuristic to select the right test cases when test driving a join query.
What a great party. Thanks again for participating and writing all those great posts.
This T-SQL Tuesday was part of my "A Join A Day" blog post series. You can find the table of contents with all posts published so far in the introductory post: A Join A Day – Introduction. Check back there frequently throughout the month.
You must be logged in to post a comment.
Pingback: T-SQL Tuesday Topics – December 2012 Update « Voice of the DBA
Pingback: 2012 T-SQL Tuesdays – T-SQL Tuesday