A recent Simple-talk article by Kathi Kellenberger dissected the fastest
SQL solution, submitted by Peter Larsson as part of Phil Factor's
SQL Speed Phreak challenge, to the classic "running total" problem. In its analysis of the code, the article re-ignited
a heated debate regarding the techniques that should, and should not, be deemed acceptable in your search for fast
SQL code. Peter's code for running total calculation uses
a variation of
a somewhat contentious technique, sometimes referred to as
a "quirky update": SET @Subscribers = Subscribers = @Subscribers + PeopleJoined - PeopleLeft This form of the UPDATE statement, @variable = column = expression, is documented and it allows you to set
a variable to the value returned by the expression. Microsoft does not guarantee the order in which rows are updated in this technique because, in relational theory,
a table doesn’t have
a natural order to its rows and the UPDATE statement has no means of specifying the order. Traditionally, in cases where
a specific order is requires, such as for running aggregate calculations, programmers who used the technique have relied on the fact that the UPDATE statement, without the WHERE clause, is executed in the order imposed by the clustered index, or in heap order, if there isn’t one. Peter wasn’t satisfied with this, and so used the ingenious device of assuring the order of the UPDATE by the use of an "ordered CTE", based on an underlying temporary staging table (a heap). However, in either case, the ordering is still not guaranteed and, in addition, would be broken under conditions of parallelism, or partitioning. Many argue, with validity, that this reliance on
a given order where none can ever be guaranteed is an abuse of basic relational principles, and so is
a bad practice; perhaps even irresponsible. More importantly, Microsoft doesn't wish to support the technique and offers no guarantee that it will always work. If you put it into production and it breaks in
a later version, you can't file
a bug. As such, many believe that the technique should never be tolerated in
a production system, under any circumstances. Is this attitude justified? After all, both forms of the technique, using
a clustered index to guarantee the order or using an ordered CTE, have been tested rigorously and are proven to be robust; although not guaranteed by Microsoft, the ordering is reliable, provided none of the conditions that are known to break it are violated. In Peter's particular case, the technique is being applied to
a temporary table, where the developer has full control of the data ordering, and indexing, and knows that the table will never be subject to parallelism or partitioning. It might be argued that, in such circumstances, the technique is not really "quirky" at all and to ban it from your systems would server no real purpose other than to deprive yourself of
a reliable technique that has uses that extend well beyond the running total calculations. Of course, it is doubly important that such
a technique, including its unsupported status and the assumptions that underpin its success, is fully and clearly documented, preferably even when posting it online in
a competition or forum post. Ultimately, however, this technique has been available to programmers throughout the time Sybase and
SQL Server has existed, and so cannot be lightly cast aside, even if one sympathises with Microsoft for the awkwardness of maintaining an archaic way of doing updates. After all,
a Table hint could easily be devised that, if specified in the WITH (<Table_Hint_Limited>) clause, could be used to request the database engine to do the update in the conventional order. Then perhaps everyone would be satisfied. Cheers, Tony.
