Question

Here is a simplified version of my table:

group price spec
a     1     .
a     2     ..
b     1     ...
b     2
c     .
.     .
.     .

I’d like to produce a result like this: (I’ll refer to this as result_table)

price_a |spec_a |price_b |spec_b |price_c ...|total_cost
1       |.      |1       |..     |...        |
(min)            (min)                        =1+1+...

Basically I want to:

1. select the rows containing the min price within each group
2. combine columns into a single row

I know this can be done using several queries and/or combined with some non-sql processing on the results, but I suspect that there maybe better solutions.

The reason that I want to do task 2 (combine columns into a single row)
is because I want to do something like the following with the result_table:

select *,
(result_table.total_cost + table1.price + table.2.price) as total_combined_cost
from result_table 
right join table1
right join table2

This may be too much to ask for, so here is some other thoughts on the problem:

Instead of trying to combine multiple rows(task 2), store them in a temporary table
(which would be easier to calculate the total_cost using sum)

Feel free to drop any thoughts, don’t have to be complete answer, I feel it’s brilliant enough if you have an elegant way to do task 1 !

==Edited/Added 6 Feb 2012==

The goal of my program is to identify best combinations of items with minimal cost (and preferably possess higher utilitarian value at the same time).

Consider @ypercube’s comment about large number of groups, temporary table seems to be the only feasible solution. And it is also pointed out there is no pivoting function in MySQL (although it can be implemented, it’s not necessary to perform such operation).

Okay, after study @Johan’s answer, I’m thinking about something like this for task 1:

select * from
(
    select * from
    result_table
    order by price asc
) as ordered_table
group by group
;

Although looks dodgy, it seems to work.

==Edited/Added 7 Feb 2012==

Since there could be more than one combination may produce the same min value, I have modified my answer :

select result_table.* from  
(
    select * from
    (
        select * from
        result_table
        order by price asc
    ) as ordered_table
    group by group
) as single_min_table
inner join result_table
on result_table.group = single_min_table.group
and result_table.price = single_min_table.price 
;

However, I have just realised that there is another problem I need to deal with:
I can not ignore all the spec, since there is a provider property, items from different providers may or may not be able to be assembled together, so to be safe (and to simplify my problem) I decide to combine items from the same provider only, so the problem becomes:

For example if I have an initial table like this(with only 2 groups and 2 providers):

id group price spec provider
1  a     1     .    x
2  a     2     ..   y
3  a     3     ...  y
4  b     1     ...  y
5  b     2          x
6  b     3          z 

I need to combine

id group price spec provider
1  a     1     .    x
5  b     2          x

and

2  a     2     ..   y
4  b     1     ...  y

record (id 6) can be eliminated from the choices since it dose not have all the groups available.

So it’s not necessarily to select only the min of each group, rather it’s to select one from each group so that for each provider I have a minimal combined cost.

Answer 1

Producing the total_cost only:

SELECT SUM(min_price) AS total_cost
FROM 
    ( SELECT MIN(price) AS min_price
      FROM TableX
      GROUP BY `group`
    ) AS grp

If a result set with the minimum prices returned in row (not in column) per group is fine, then your problem is of the gretaest-n-per-group type. There are various methods to solve it. Here’s one:

SELECT tg.grp 
       tm.price AS min_price
       tm.spec 
FROM
      ( SELECT DISTINCT `group` AS grp
        FROM TableX
      ) AS tg 
  JOIN
      TableX AS tm
    ON 
      tm.PK =                             --- the Primary Key of the table
      ( SELECT tmin.PK 
        FROM TableX AS tmin
        WHERE tmin.`group` = tg.grp
        ORDER BY tmin.price ASC
        LIMIT 1
      )