What SQL magic do I need to turn one column into several? - sql

Question

I need to print some tickets, each of which has enough room to hold one set of customer details along with codes for up to five items ordered by that customer. Customers who have ordered more than five items get multiple tickets. So from an orders table like this,
Customer | Item
---------|------
Bob | FTMCH
Bob | ZORP
Bob | KLUGE
Carol | FTMCH
Carol | MEEP
Carol | ZORP
Ted | FOON
Ted | SMOCK
Alice | ORGO
Carol | SQICK
Carol | BLECH
Carol | KLUGE
Carol | GLURP
I need a query that returns this:
Customer | Item1 | Item2 | Item3 | Item4 | Item5
---------|-------|-------|-------|-------|------
Alice | ORGO | null | null | null | null
Bob | FTMCH | ZORP | KLUGE | null | null
Carol | FTMCH | MEEP | ZORP | SQICK | BLECH
Carol | KLUGE | GLURP | null | null | null
Ted | FOON | SMOCK | null | null | null
Can some kind soul help me with the SQL for this? HSQL embedded database in OpenOffice.org Base, if it makes a difference.

Answer 1

OK, this works well enough:
SELECT
"Customer",
MAX(CASE WHEN "Slot" = 0 THEN "Item" END) AS "Item1",
MAX(CASE WHEN "Slot" = 1 THEN "Item" END) AS "Item2",
MAX(CASE WHEN "Slot" = 2 THEN "Item" END) AS "Item3",
MAX(CASE WHEN "Slot" = 3 THEN "Item" END) AS "Item4",
MAX(CASE WHEN "Slot" = 4 THEN "Item" END) AS "Item5"
FROM (
SELECT
l."Customer" AS "Customer",
l."Item" AS "Item",
COUNT(r."Item") / 5 AS "Ticket",
MOD(COUNT(r."Item"), 5) AS "Slot"
FROM "Orders" AS l
LEFT JOIN "Orders" AS r
ON r."Customer" = l."Customer" AND r."Item" < l."Item"
GROUP BY "Customer", "Item"
)
GROUP BY "Customer", "Ticket"
ORDER BY "Customer", "Ticket"
It makes this:
Customer | Item1 | Item2 | Item3 | Item4 | Item5
---------|-------|-------|-------|-------|-------
Alice | ORGO | | | |
Bob | FTMCH | KLUGE | ZORP | |
Carol | BLECH | FTMCH | GLURP | KLUGE | MEEP
Carol | SQICK | ZORP | | |
Ted | FOON | SMOCK | | |
Thanks to all who helped, both here and at Ask Metafilter.
(Followup edit:)
Jesus, this just gets worse :-(
Turns out the business rules allow the same customer to order the same item on multiple occasions, and that all outstanding orders are to be included on the one set of tickets. So my toy table should have looked more like this:
ID | Customer | Item
159 | Bob | FTMCH
264 | Bob | ZORP
265 | Bob | KLUGE
288 | Carol | FTMCH
314 | Carol | MEEP
323 | Carol | ZORP
327 | Ted | FOON
338 | Ted | SMOCK
358 | Alice | ORGO
419 | Carol | SQICK
716 | Carol | MEEP
846 | Carol | BLECH
939 | Carol | MEEP
950 | Carol | GLURP
979 | Carol | KLUGE
Carol's multiple MEEPs bugger the ranking logic in the original solution, and I've ended up with the following hideous monster:
SELECT
"Customer",
MAX(CASE WHEN "Slot" = 0 THEN "Item" END) AS "Item0",
MAX(CASE WHEN "Slot" = 1 THEN "Item" END) AS "Item1",
MAX(CASE WHEN "Slot" = 2 THEN "Item" END) AS "Item2",
MAX(CASE WHEN "Slot" = 3 THEN "Item" END) AS "Item3",
MAX(CASE WHEN "Slot" = 4 THEN "Item" END) AS "Item4",
MAX(CASE WHEN "Slot" = 0 THEN "Quantity" END) AS "Qty0",
MAX(CASE WHEN "Slot" = 1 THEN "Quantity" END) AS "Qty1",
MAX(CASE WHEN "Slot" = 2 THEN "Quantity" END) AS "Qty2",
MAX(CASE WHEN "Slot" = 3 THEN "Quantity" END) AS "Qty3",
MAX(CASE WHEN "Slot" = 4 THEN "Quantity" END) AS "Qty4"
FROM (
SELECT
"Customer",
"Item",
COUNT("ID") AS "Quantity",
"Rank" / 5 AS "Ticket",
MOD("Rank", 5) AS "Slot"
FROM (
SELECT
main."ID" AS "ID",
main."Customer" AS "Customer",
main."Item" AS "Item",
COUNT(less."Item") AS "Rank"
FROM "Orders" AS main
LEFT JOIN (
SELECT DISTINCT
"Customer",
"Item"
FROM "Orders") AS less
ON less."Customer" = main."Customer" AND less."Item" < main."Item"
GROUP BY "ID", "Customer", "Item"
)
GROUP BY "Customer", "Item", "Rank"
)
GROUP BY "Customer", "Ticket"
which makes this:
Customer | Item0 | Item1 | Item2 | Item3 | Item4 | Qty0 | Qty1 | Qty2 | Qty3 | Qty3 | Qty4
Bob | FTMCH | KLUGE | ZORP | | | 1 | 1 | 1 | | |
Carol | BLECH | FTMCH | GLURP | KLUGE | MEEP | 1 | 1 | 1 | 1 | 1 | 3
Carol | SQICK | ZORP | | | | 1 | 1 | | | |
Ted | FOON | SMOCK | | | | 1 | 1 | | | |
Alice | ORGO | | | | | 1 | | | | |
It does the job, I guess, but I'm feeling pretty lucky that the database involved is always going to be quite small (a few thousand rows).
Spiritually I'm an embedded-systems guy, not a database guy. Can anybody who does this for a living tell me whether this kind of nonsense is common? Would a query with four nested SELECTs and a LEFT JOIN merit a mention on the Daily WTF?

Answer 2

I believe this is only usable for T-SQL, but you can use PIVOT: http://msdn.microsoft.com/en-us/library/ms177410.aspx
I did something similar with a list of dates becoming the columns for calculations.

Answer 3

Not exactly what you asked, and MySQL rather than OpenOffice, but might give you an idea or someone else could work on it :
select
u.Customer,
group_concat(u.Item) items
from
(select
t.Item,
#n:=if(#c=t.Customer and #n<4,#n+1,0) c1,
#m:=if(#n,#m,#m+1) g,
#c:=t.Customer as Customer
from
t1 t, (select #m:=0) init
order
by t.Customer
) u
group by
u.g
Output :
+----------+------------------------------+
| Customer | items |
+----------+------------------------------+
| Alice | ORGO |
| Bob | FTMCH,ZORP,KLUGE |
| Carol | KLUGE,ZORP,BLECH,SQICK,GLURP |
| Carol | MEEP,FTMCH |
| Ted | FOON,SMOCK |
+----------+------------------------------+

Answer 4

This gets you most of the way there, but does not handle the duplicate order for Carol. That would be easy to do if there was something else to group on, like OrderID or OrderDate. Can you post the full schema?
select m1.Customer,
min(m1.Item) as Item1,
min(m2.item) as Item2,
min(m3.item) as Item3,
min(m4.item) as Item4,
min(m5.item) as Item5
from CustomerOrder m1
left outer join CustomerOrder m2 on m1.Customer = m2.Customer
and m2.item > m1.item
left outer join CustomerOrder m3 on m1.Customer = m3.Customer
and m3.item > m2.item
left outer join CustomerOrder m4 on m1.Customer = m4.Customer
and m4.item > m3.item
left outer join CustomerOrder m5 on m1.Customer = m5.Customer
and m5.item > m4.item
group by m1.Customer
Output:
Customer Item1 Item2 Item3 Item4 Item5
-------------- ---------- ---------- ---------- ---------- ----------
Alice ORGO NULL NULL NULL NULL
Bob FTMCH KLUGE ZORP NULL NULL
Carol BLECH FTMCH GLURP KLUGE MEEP
Ted FOON SMOCK NULL NULL NULL

Answer 5

The requirement is not uncommon, and can be supplied reasonably in SQL. But you have two issues blocking you.
1) You've entered an SQL tag, that means ISO/IEC/ANSI Standard SQL. The correct method to use is a cursor or cursor substitute (while loop, which does the same thing, but is faster). That avoids all these outer joins and handling massive result sets; then beating it into submission with GROUP BYs, etc. It also handles duplicates, mainly because it does it create them in the first place (via those five versions of the aliased table). And yes, it will keep getting worse, and when the database is reasonably populated it will be a performance hog.
2) Duplicates are not allowed in a Relational database, ie. in your source tables; you need to make the rows unique (and those keys/columns is not shown). No use trying to eliminate duplicates via code. If that is corrected, then all duplicates (real and created by the poor code) can be eliminated.
This requirement can also be supplied more elegantly using Subqueries; except that here you need two levels of nesting, one to build teach Item column, and two to obtain rank or Position. And that (standard SQL construct) pre-supposes that you have a Relational database (no duplicate rows). High Eek factor if you are not used to SQL. Which is why most coders use a cursor or cursor substitute.
But if you do not have SQL, its basic capabilities, (HSQL being some sub-standard implementation), then we are not using the same tool kit. The SQL code I can provide will not run for you, and we will keep going back and forth.
(Maybe we should have a "psuedo-SQL" tag.)
ID Column Prevents Duplicates ???
There is a myth that is prevalent in some parts of the industry, to that effect, due to books written by database beginners. As usual, myths have no scientific basis. Let's try a simple test. CREATE TABLE Person (
PersonId IDENTITY NOT NULL
PRIMARY KEY,
FirstName CHAR(30) NOT NULL,
LastName CHAR(30) NOT NULL
)
INSERT Person VALUES ("Fred", "Astaire")
1 row(s) affected
INSERT Person VALUES ("Ginger", "Rogers")
1 row(s) affected
INSERT Person VALUES ("Fred", "Astaire")
1 row(s) affected
SELECT * FROM Person
PersonId FirstName LastName
======== ============================== ==============================
1 Fred Astaire
2 Ginger Rogers
3 Fred Astaire
3 row(s) affected
That's a pure, unarguable duplicate row. The simple fact is. the Id column provides a row number, but does nothing to prevent duplicate rows. For that you need an Unique Index on the columns that determine uniqueness, as identified in the data model, for every relational table in the database (by definition, if the rows are not unique, it is not a Relational table). Otherwise it is just a file storage system. CREATE UNIQUE NONCLUSTERED INDEX U_Name
ON Person (LastName, FirstName)
There is another form of data integrity (duplication) which I might identify while I am at it. INSERT Person VALUES ("Fred", "Astair")
1 row(s) affected
INSERT Person VALUES ("Astaire", "Fred")
1 row(s) affected
All are preventable in SQL.