Can't figure out the correct syntax for this select statement

Question

Hello,
The following statement works great and gives the desired results:
prompt
prompt Using WITH t
prompt
with t as
   select a.proj_id,
          a.proj_start,
          a.proj_end,
          case when (
                     select min(a.proj_start)
                       from v b
                      where (a.proj_start  = b.proj_end)
                        and (a.proj_id    != b.proj_id)
                    is not null then 0 else 1
          end as flag
     from v a
    order by a.proj_start
select proj_id,
       proj_start,
       proj_end,
       flag,
       -- the following select statement is what I am having a hard time
       -- "duplicating" without using the WITH clause
        select sum(t2.flag)
          from t t2
         where t2.proj_end <= t.proj_end
       ) s
  from t;As an academic exercise I wanted to rewrite the above statement without using the WITH clause, I tried this (among dozens of other tries - I've hit a mental block and can't figure it out):
prompt
prompt without with
prompt
select c.proj_id,
       c.proj_start,
       c.proj_end,
       c.flag,
       -- This is what I've tried as the equivalent statement but, it is
       -- syntactically incorrect.  What's the correct syntax for what this
       -- statement is intended ?
        select sum(t2.flag)
          from c t2
         where t2.proj_end <= c.proj_end
       ) as proj_grp
  from (
        select a.proj_id,
               a.proj_start,
               a.proj_end,
               case when (
                          select min(a.proj_start)
                            from v b
                           where (a.proj_start  = b.proj_end)
                             and (a.proj_id    != b.proj_id)
                         is not null then 0 else 1
               end as flag
          from v a
         order by a.proj_start
       ) c;Thank you for helping, much appreciated.
John.
PS: The DDL for the table v used by the above statements is:
drop table v;
create table v (
proj_id         number,
proj_start      date,
proj_end        date
insert into v values
       ( 1, to_date('01-JAN-2005', 'dd-mon-yyyy'),
            to_date('02-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 2, to_date('02-JAN-2005', 'dd-mon-yyyy'),
            to_date('03-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 3, to_date('03-JAN-2005', 'dd-mon-yyyy'),
            to_date('04-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 4, to_date('04-JAN-2005', 'dd-mon-yyyy'),
            to_date('05-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 5, to_date('06-JAN-2005', 'dd-mon-yyyy'),
            to_date('07-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 6, to_date('16-JAN-2005', 'dd-mon-yyyy'),
            to_date('17-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 7, to_date('17-JAN-2005', 'dd-mon-yyyy'),
            to_date('18-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 8, to_date('18-JAN-2005', 'dd-mon-yyyy'),
            to_date('19-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       ( 9, to_date('19-JAN-2005', 'dd-mon-yyyy'),
            to_date('20-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       (10, to_date('21-JAN-2005', 'dd-mon-yyyy'),
            to_date('22-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       (11, to_date('26-JAN-2005', 'dd-mon-yyyy'),
            to_date('27-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       (12, to_date('27-JAN-2005', 'dd-mon-yyyy'),
            to_date('28-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       (13, to_date('28-JAN-2005', 'dd-mon-yyyy'),
            to_date('29-JAN-2005', 'dd-mon-yyyy'));
insert into v values
       (14, to_date('29-JAN-2005', 'dd-mon-yyyy'),
            to_date('30-JAN-2005', 'dd-mon-yyyy'));

Answer 1

Hi, John,
Not that you asked, but as you proabably know, analytic functions are much better at doing this kind of thing.
You may be amazed (as I continually am) by how simple and efficient these queries can be.
For example:
WITH     got_grp          AS
     SELECT     proj_id, proj_start, proj_end
     ,     proj_end - SUM (proj_end - proj_start) OVER (ORDER BY  proj_start)     AS grp
     FROM     v
SELECT       ROW_NUMBER () OVER (ORDER BY grp)     AS proj_grp
,       MIN (proj_start)                         AS proj_start
,       MAX (proj_end)               AS proj_end
FROM       got_grp
GROUP BY  grp
ORDER BY  proj_start
;Produces the results you want:
  PROJ_GRP PROJ_START  PROJ_END
         1 01-Jan-2005 05-Jan-2005
         2 06-Jan-2005 07-Jan-2005
         3 16-Jan-2005 20-Jan-2005
         4 21-Jan-2005 22-Jan-2005
         5 26-Jan-2005 30-Jan-2005This is problem is an example of Neighbor-Defined Groups . You want to GROUP BY something that has 5 distinct values, to get the 5 rows above, but there's nothing in the table itself that tells you to which group each row belongs. The groups are not defined by any column in hte table, but by relationships between rows. In this case, a row is in the same group as its neighbor (the row immediatly before or after it when sorted by proj_start or proj_end) if proj_end of the earlier row is the same as proj_start of the later row. That is, there is nothing about 03-Jan-2005 that says the row with proj_id=2 is in the first group, or even that it is in the same group with its neighbor, the row with proj_id=3. Only the relation between those rows, the fact that the earlier row has end_date=03-Jan-2005 and the later row has start_date=03-Jan-2003, that says these neighbors belong to the same group.
You're figuring out when a new group starts, and then counting how many groups have already started to see to which group each row belongs. That's a prefectly natural procedural way of approaching the problem. But SQL is not a procedural language, and sometimes another approach is much more efficient. In this case, as in many others, a Constant Difference defines the groups. The difference between proj_end (or proj_start, it doesn't matter in this case) and the total duratiojn of the rows up to that date determines a group. The actual value of that difference means nothing to you or anybody else, so I used ROW_NUMBER in the query above to map those distinct values into consecutive integers 1, 2, 3, ... which are a much simpler way to identify the groups.
Note that the query above only requires one pass through the table, and only requires one sub-query. It does not need a WITH clause; you could easily make got_grp an in-line view.
If you used analytic functions (LEAD or LAG) to compute flag, and then to compute proj_grp (COUNT or SUM), you would need two sub-queries, one for each analytic function, but you would still only need one pass through the table. Also, those sub-queries could be in-line views; yiou would not need to use a WITH clause.