Switching rows and columns in SQL

When they use SQL Server, one the commoner questions that Ms Access programmers ask is 'Where's the TRANSFORM/PIVOT command? So how do you swap colums and rows in an aggregate table? Do you really need to use a CLR routine for this?

Recently, I came across a description of a transformation operation using SQL Server CLR – the goal is to convert, or transpose, columns into rows and rows into columns. Microsoft ACCESS has a SQL TRANSFORM /PIVOT extension to SQL that automatically produces a crosstab query, and SQL Server 2005 introduced the pivot command, but neither simply swaps columns and rows. The problem was to replicate this sort of functionality in SQL Server. It’s possible to write a CLR function to transform the data, however, I believe that a set-based T-SQL query is the preferred solution to this type of problem.

In the example of the CLR transform function, the source data included columns for PaymentDate, and three types of payments:


Once transformed the result would swap the columns and rows to this configuration:


The following script creates the test table and populates it with the sample test data:

The root cause behind this transformation is that the three payment columns violate first normal form. Column names that include data (Medicare, Medicaid, VA) is clear indication that first normal form is being ignored with repeating columns. Had the source data been properly normalized there would been no need to transform the columns and rows. If you find yourself needing to perform this type of transformation regularly, then you have a problem with your schema design. A normalized version of the source table should have columns for PaymentDate, PaymentType, and Amount.

But assuming the denormalized data is all that’s available, Microsoft provides a straight-forward solution using the Pivot and UnPivot commands available since SQL Server 2005. The key is recognizing that the source data violated first normal form, and that the unpivot command is designed specifically to normalize this type of unnormalized data. In the query below, the sq subquery first uses an unpivot command to normalize the data which is then passed to the pivot command in the outer query. Pairing the unpivot and pivot command makes quick work of the transformation task. The only trick in the query is appending a “d” before each date so the pivot command will accept it as a column name:

We make some assumptions about the nature of the data when we use the MIN aggregate function. The routine expects to ignore duplicate entries for a particular PaymentDate if there are any.

Before SQL Server 2005, you would have had to use the slightly more convoluted code …

You’ll see that this would give different results from the first solution if there is duplicate data in the original aggregate table 

There have been several attempts to create a generic solution that emulates the TRANSFORM/PIVOT functionality ,(Rob Volk’s being probably the best known, Dynamic Cross-Tabs/Pivot Tables, but see also Creating cross tab queries and pivot tables in SQL) but the PIVOT/UNPIVOT functionality of SQL Server 2005 onwards makes such devices unnecessary.

The example provides two lessons for SQL server designers and developers. First – don’t underestimate the power of the set-based query. Turning to the CLR for a solution when T-SQL can solve the problem is nearly always an error. Perhaps a more significant lesion is that there’s a performance cost to denormalization when additional code is required to re-normalize the data. The programmer’s cliché, “Normalize till is hurts, then denormalize till it works,” simply isn’t true.

Tags: , , ,


  • Rate
    [Total: 10    Average: 4/5]
  • Anonymous

    Not a normalization issue
    Fine example of how to pivot. Less good is the claim that “three payment columns violate first normal form”. That isn’t so and it repeats a common misunderstanding of what 1NF means.

    A table is in 1NF if it accurately represents a relation – ie. no duplicate rows or nulls permitted. 1NF requires nothing about the attributes of a relation other than that their values must all be drawn from some specific domain (which is implicit in the definition of a relation or SQL table anyway).


  • John O’Sullivan

    SQL Pivot
    The Pivot command in SQL is very disappointing, having to specify columns is not very good.

  • puzsol

    Ugly example
    Sorry, but I can’t help but think this is a horrible example… It can’t be used for a different date range, without the query being re-written… and the manipulation seems to be purely for some manager who wants the data axies swapped… which if you ask me belongs in the reporting application, not in an SQL query.

  • Phil Factor

    Re: Ugly Example
    Here’s a possible solution, using dynamic SQL, that doesn’t rely on you having to key in the date range.

    CREATE PROCEDURE TransformPaymentInfo
    FROM    information_Schema.tables
    WHERE   table_Name LIKE ‘Payment’ )
    @Command VARCHAR(MAX)
    SELECT  @Subcommand=
    Select ”$$” as [type]’
    SELECT  @Subcommand=@Subcommand+‘,
    sum(case when PaymentDate=convert(DateTime,”’
    +CONVERT(VARCHAR(20), PaymentDate, 101)
    ”’,101) then  [$$] else 0 end) as [‘
    +CONVERT(VARCHAR(20), PaymentDate, 101)+‘]’
    FROM    payment GROUP BY PaymentDate
    SELECT  @Command=COALESCE(@Command+
    from ‘
    Union All
    , )+REPLACE(@SubCommand, ‘$$’, column_Name)
    FROM    information_Schema.columns
    WHERE   table_Name LIKE ‘Payment’
    AND column_name NOT IN (‘PaymentID’, ‘PaymentDate’)
    SELECT  @command=@Command+
    from payment’
    SELECT @command
    EXECUTE (@command)

  • Paul Nielsen

    1NF violation
    While the columns Medicare, Medicaid, and VA columns have different names they are indeed duplicate, repeating columns. Each column represents a payment received from a source. Rather than model the sources as a table, the souces are represented in column names – a clear indicator of a poor table design.

  • Anonymous

    Poor design? Very possibly. Violation of 1NF? No.
    Hi Paul,

    1NF doesn’t make any restrictions on column names (other than that they must be unique) or on repeating the same type of attribute in a table.

    “Repeating groups” (multivalued attributes) are a violation of 1NF but SQL Server doesn’t support repeating groups in tables so that concept is not applicable.

    The distinction is important because 1NF frequently gets abused in all sorts of unjustified ways – hence Anith’s useful little “Facts and Fallacies” article.

  • PhoenixR

    1NF violation
    In my opinion this restriction does not apply to the column name but rather to the redundant information source.In this case it seems to me that they hold the same type of information and could easily be replaced by one PaymentType column.What would happen if a new payment source were to be added ? new column ? what about 1000 ?

  • Heravar

    On a good design
    Leaving aside the debate about 1NF violations, I have a doubt.

    The article says: “Had the source data been properly normalized (let’s call this, been designed as: PaymentDate, PaymentType, and Amount.) there would been no need to transform the columns and rows…”

    In a “PaymentDate, PaymentType, Amount” schema, how would you do that Transform/Pivot?

  • Dalex

    Dynamic row transposing
    To easily transpose columns into rows with its names you should use XML. In my blog I was described this with example: http://sql-tricks.blogspot.com/2011/04/sql-server-rows-transpose.html

  • Rohankaza

    With out Unpivot
    Can we do this without a pivot approach.
    I see many blogs showing row values to a column name using a pivot,
    is there any other way?