MAX for each subset

aggregateoracle

I have a table that looks like this:

+---------------------------------------------+
| EVENT_ID | ITEM_ID | PERSON_ID | EVENT_DATE |
+---------------------------------------------+
| 123      | 1       | 2         | 21-AUG-03  |
| 124      | 1       | 3         | 22-AUG-03  |
| 125      | 1       | 45        | 23-AUG-03  |
| 126      | 1       | (null)    | 24-AUG-03  |
| 127      | 2       | 2         | 25-AUG-03  |
| 128      | 2       | 6         | 26-AUG-03  |
| 129      | 2       | 1         | 27-AUG-03  |
+---------------------------------------------+

So, I need to get the latest (MAX(event_date)), non-null person_id per item_id. We have come up with a fairly simple PL/SQL approach to this, but were trying to get the job done with straight SQL. Anyone have an idea?

Just as a side-note, the event_id will not always be sequential like this. We have two redundant DB servers.

Thanks ahead of time.

Best Answer

Try this

create table event_table (
    event_id int,
    item_id int,
    person_id int,
    event_date date
);

insert into event_table values (123, 1, 2,    to_date('21-aug-03','DD-MON-YY'));
insert into event_table values (124, 1, 3,    to_date('22-aug-03','DD-MON-YY')); 
insert into event_table values (125, 1, 45,   to_date('23-aug-03','DD-MON-YY'));  
insert into event_table values (126, 1, null, to_date('24-aug-03','DD-MON-YY'));  
insert into event_table values (127, 2, 2,    to_date('25-aug-03','DD-MON-YY'));  
insert into event_table values (128, 2, 6,    to_date('26-aug-03','DD-MON-YY'));  
insert into event_table values (129, 2, 1,    to_date('27-aug-03','DD-MON-YY'));  


select * from event_table;

select t1.item_id, t1.Person_id, t1.event_date
from event_table t1
join 
(select item_id , max(event_date) max_event_date 
   from event_table where Person_id is not null group by item_id ) t2 
on t1.item_id = t2.item_id and t1.event_date = t2.max_event_date;

Related Solutions

Pivoting data for stacked charts (grouping and creating new columns for each distinct value)

Another way to do this if the columns are known is using an aggregate and a CASE statement:

SELECT d,
  sum(case when loc = 'Baltimore' then v else 0 end) as Baltimore,
  sum(case when loc = 'Houston' then v else 0 end) as Houston,
  sum(case when loc = 'Chicago' then v else 0 end) as Chicago
FROM test
group by d
order by d;

See SQL Fiddle with Demo

If you want to do this dynamically, then you can create a procedure to generate the SQL statement:

CREATE OR REPLACE procedure dynamic_pivot(p_cursor in out sys_refcursor)
as
    sql_query varchar2(1000) := 'select d ';

    begin
        for x in (select distinct loc from test order by 1)
        loop
            sql_query := sql_query ||
                ' , sum(case when loc = '''||x.loc||''' then v end) as '||x.loc;

                dbms_output.put_line(sql_query);
        end loop;

        sql_query := sql_query || ' from test group by d order by 1';

        open p_cursor for sql_query;
    end;
/

Then to call it:

variable x refcursor
exec dynamic_pivot(:x)
print x

the result is:

D                                BALTIMORE    CHICAGO    HOUSTON
------------------------------- ---------- ---------- ----------
01-JAN-12 12.00.00.000000 AM            36         55         36
01-FEB-12 12.00.00.000000 AM            49         51         58
01-MAR-12 12.00.00.000000 AM            11         18         13

Nesting MAX for SELECT

It can be done with a query:

SELECT 
    s.*
FROM
  ( SELECT DISTINCT series_id
    FROM series
  ) AS ds
  JOIN
    series AS s
      ON  s.series_id = ds.series_id
      AND s.season =
          ( SELECT si.season
            FROM series AS si
            WHERE si.series_id = ds.series_id
            ORDER BY si.season DESC
            LIMIT 1
          ) 
      AND s.episode =
          ( SELECT si.episode
            FROM series AS si
            WHERE si.series_id = ds.series_id
            ORDER BY si.season DESC, si.episode DESC
            LIMIT 1
          ) ;

Tested at SQL-Fiddle

With an index on (series_id, season, episode), it should be quite efficient, if the number of series_id is small.

CREATE UNIQUE INDEX uix
  ON series
  (series_id, season, episode) ;

There are several ways to do this query but all get rather complicated because the maximum needed is based on two columns (season and episode). Here's another one, which is the query above, simplified a bit:

SELECT 
    s.*
FROM
  ( SELECT series_id, MAX(season) AS season
    FROM series
    GROUP BY series_id
  ) AS ds
  JOIN
    series AS s
      ON  s.series_id = ds.series_id
      AND s.season = ds.season
      AND s.episode =
          ( SELECT si.episode
            FROM series AS si
            WHERE si.series_id = ds.series_id
              AND si.season = ds.season
            ORDER BY si.episode DESC
            LIMIT 1
          ) ;

and another using NOT EXISTS:

SELECT s.*
FROM series AS s
WHERE NOT EXISTS
      ( SELECT 1
        FROM series AS sb
        WHERE sb.series_id = s.series_id
          AND ( sb.season > s.season
             OR sb.season = s.season AND sb.episode > s.episode
              )
      ) ;

Best Answer

Related Solutions

Pivoting data for stacked charts (grouping and creating new columns for each distinct value)

Nesting MAX for SELECT

Related Question