Grouping Header Rows based on common rows in Details

Question

Hi,
I have two tables TAB_MST and TAB_DTL with information like below:
{code}
CREATE TABLE TAB_MST
  MSTCOL  NUMBER
ALTER TABLE TAB_MST ADD CONSTRAINT TAB_MST_PK PRIMARY KEY (MSTCOL)
INSERT INTO TAB_MST (MSTCOL) VALUES (1);
INSERT INTO TAB_MST (MSTCOL) VALUES (2);
INSERT INTO TAB_MST (MSTCOL) VALUES (3);
INSERT INTO TAB_MST (MSTCOL) VALUES (4);
CREATE TABLE TAB_DTL
  MSTCOL  NUMBER,
  DTLCOL  NUMBER
ALTER TABLE TAB_DTL ADD CONSTRAINT TAB_DTL_PK PRIMARY KEY (MSTCOL, DTLCOL)
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (1, 1);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (1, 2);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (1, 3);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (1, 4);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (1, 5);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (2, 4);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (2, 7);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (2, 8);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (2, 9);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (3, 8);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (3, 9);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (3, 10);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (3, 11);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (4, 12);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (4, 13);
INSERT INTO TAB_DTL (MSTCOL, DTLCOL) VALUES  (4, 14);
COMMIT;
{code}
I want to group rows in Master table (TAB_MST) to different groups based on the data in detail table (TAB_DTL) with output as below
MSTCOL      GROUPID
     1               1
     2               1
     3               1
     4               2
Rule for Grouping are as follows:
1) If there is any common value of DTLCOL for two different values of MSTCOL, then both MSTCOL values should be grouped under same group, e.g. for above sample case
DTLCOL (Value = 4) is common for MSTCOL = 1 and MSTCOL = 2, hence MSTCOL 1 and MSTCOL 2 belong to same group (GROUPID = 1).
DTLCOL (Value = 8, 9) is common for MSTCOL = 2 and MSTCOL = 3, hence MSTCOL 3 should belong to same group as MSTCOL 2 (GROUPID = 1)
There is no common value of DTLCOL for MSTCOL = 4, hence it is in a separate group.
Below is the sample PL/SQL block to highlight this grouping behavior. Two temporary tables are created to achieve this:
{code}
CREATE TABLE TAB_MST_GROUP
  MSTCOL   NUMBER,
  GROUPID  NUMBER
CREATE TABLE TAB_TMP_GROUP
  GROUPID  NUMBER
DECLARE
   CURSOR c1
   IS
      SELECT * FROM tab_mst;
   prevmstcol    NUMBER;
   prevgroupid   NUMBER := 1;
   vtmpgroupid   NUMBER;
BEGIN
   DELETE tab_mst_group;
   FOR r1 IN c1
   LOOP
      IF prevmstcol IS NULL
      THEN
         INSERT INTO tab_mst_group
              VALUES (r1.mstcol, prevgroupid);
         prevmstcol := r1.mstcol;
      ELSE
         INSERT INTO tab_tmp_group
            SELECT DISTINCT groupid
              FROM tab_mst_group a, tab_dtl b, tab_dtl c
             WHERE     a.mstcol = b.mstcol
                   AND c.dtlcol = b.dtlcol
                   AND c.mstcol = r1.mstcol;
         IF SQL%ROWCOUNT = 0
         THEN
            prevgroupid := prevgroupid + 1;
            INSERT INTO tab_mst_group
                 VALUES (r1.mstcol, prevgroupid);
         ELSE
            SELECT MIN (groupid) INTO vtmpgroupid FROM tab_tmp_group;
            UPDATE tab_mst_group
               SET groupid = vtmpgroupid
             WHERE groupid IN (SELECT groupid FROM tab_tmp_group);
            INSERT INTO tab_mst_group
                 VALUES (r1.mstcol, vtmpgroupid);
            SELECT MAX (groupid) INTO prevgroupid FROM tab_mst_group;
            DELETE tab_tmp_group;
         END IF;
      END IF;
   END LOOP;
END;
{code}
Question:
a. Can we achieve this in SQL instead of PL/SQL?
b. Overhead of read from TAB_DTL grows exponentially if the No of records in TAB_MST grows. How can we reduce the no of read from TAB_DTL as the actual no of rows in TAB_DTL are very high.
Thanks,
sukhijank

Answer 1

Hi, Sukhijank,
Thanks for the additional information.  You didn't just learn those details since posting your first message, did you?  If you post information like that in your first message, then people can use it to give you a better answer in the first reply.
The idea I had for a recursive WITH clause solution won't work after all.
I think the best solution will be in PL/SQL, using a table like tab_mst_group which you posted, but with an additional column:
CREATE TABLE TAB_MST_GROUP
  mstcol NUMBER PRIMARY KEY,
  groupid   NUMBER,
  levelnum NUMBER
CREATE INDEX tab_mst_group_groupid_levelnum
ON     tab_mst_group (levelnum, groupid);
If llevelnum = 0, that means the assignment of the groupid is not certain; if levelnum > 0, then groupid is correct.
Here's a procedure you can use to populate the table:
CREATE OR REPLACE PROCEDURE tab_mst_group_populate
AS
    new_groupid  tab_mst_group.groupid%TYPE
     := 0;
    new_levelnum tab_mst_group.levelnum%TYPE;
    num_added  PLS_INTEGER;
    truncate_stmt VARCHAR2 (50) := 'TRUNCATE TABLE tab_mst_group';
BEGIN
    --  *****  Remove old entries from the table  *****
    -- dbms_output.put_line (truncate_stmt || ' = truncate_stmt in tab_mst_group_populate'); -- Debugging
    EXECUTE IMMEDIATE  truncate_stmt;
    --  *****  Populate table with all mstcols, and 1-member groups  *****
    INSERT INTO  tab_mst_group (mstcol, groupid, levelnum)
    SELECT    m.mstcol
    ,       m.mstcol  AS groupid
    ,       MIN ( CASE
                     WHEN  o.mstcol IS NULL
     THEN  1
     ELSE  0
                 END
    )  AS lvlnum
    FROM     tab_mst    m
    LEFT JOIN tab_dtl    d ON  d.mstcol = m.mstcol
    LEFT JOIN tab_dtl    o ON  o.dtlcol = d.dtlcol
            AND o.mstcol   != d.mstcol
    GROUP BY    m.mstcol;
    --  ***** Get groupid for lowest mstcol that still needs one  *****
    WHILE  new_groupid IS NOT NULL
    LOOP
        SELECT  MIN (groupid)
INTO new_groupid
FROM tab_mst_group
WHERE levelnum = 0;
IF  new_groupid   IS NOT NULL
THEN
     --  ***  Confirm groupid for this one mstcol  ***
     UPDATE  tab_mst_group
     SET     levelnum = 1
     WHERE   levelnum = 0
     AND     groupid = new_groupid;
     new_levelnum := 2;
     num_added := 1;
     --  ***  Add neighboring mstcols to this group  ***
     WHILE  num_added > 0
     LOOP
         UPDATE  tab_mst_group
  SET groupid   = new_groupid
  , levelnum  = new_levelnum
  WHERE levelnum  = 0
  AND groupid   IN (
                   SELECT  d2.mstcol
            FROM  tab_mst_group g1
      JOIN  tab_dtl       d1  ON  d1.mstcol  = g1.mstcol
      JOIN  tab_dtl       d2  ON  d2.dtlcol  = d1.dtlcol
                    AND d2.mstcol != d1.mstcol
      JOIN  tab_mst_group g2  ON  g2.mstcol  = d2.mstcol
      WHERE  g1.levelnum  = new_levelnum - 1
      AND  g1.groupid   = new_groupid
      AND  g2.levelnum  = 0
  num_added := SQL%ROWCOUNT;
  dbms_output.put_line (num_added || ' = num_added');
         new_levelnum := new_levelnum + 1;
     END LOOP;
END IF;
    END LOOP;
END tab_mst_group_populate;
SHOW ERRORS
The basic strategy is that we start off assuming that every mstcol will be its own groupid.  The CASE expression in the INSERT statement sets levelnum = 1 for mstcols that do not exist in the tab_dtl table, or are not related to other mstcols in tab_dtl.  The loop after that looks for rows in tab_mst_group that are still 0, meaning that the assignment of grpupid still has to be confirmed or changed.  It starts by finding the lowest mstcol that still has levelnum = 0, and makes that a new group.  The inner loop looks for related mstcols and marks them as being in the same group.
You might combine tab_mst and tab_mst_group; I don't see any need to have a separate table (but maybe you do).  If you do combine them, then you wouldn't truncate the table in the procedure.