Hierarchical query with out using Connect by prior

Question

Hi Guys,
I am supporting a product which is enterprise based and only allowd to write queries which are ANSII standard.
I have an requirement like If I provide the child I need to know all the parents till  highest level.
My table structure is like below
Table_name :  Org_unit
Columns are
Org_unit_id name desc  parent_org_unit_id
I wil pass the org_unit id and want to list all the parents of the chile org_unit_id and it has to be accomplished without  using connec by prior.
Please suggest me some ideas and aprroches
I am using Orcle 11g version

Answer 1

Hi,
960593 wrote:
Hi Guys,
I am supporting a product which is enterprise based and only allowd to write queries which are ANSII standard.
I have an requirement like If I provide the child I need to know all the parents till  highest level.
My table structure is like below
Table_name :  Org_unit
Columns are
Org_unit_id name desc  parent_org_unit_id
I wil pass the org_unit id and want to list all the parents of the chile org_unit_id and it has to be accomplished without  using connec by prior.
Please suggest me some ideas and aprroches
I am using Orcle 11g version
The data model you posted (org_unit_id as primary key, parent_org_unit_id as foreign key to the same table for the parent, when there is a parent) is called the Adjacency Model because it keeps track of which nodes are adjacent (or next to) each other.
I'm familiar with 2 other ways to model hierarchies: the Nested Sets Model, and what I call the Lineage Model.  I'll show how to find a given node's ancestors (in hierarchical order) in each model.  Neither the Nested Sets nor the Lineage Model requires CONNECT BY or recursive WITH clauses to work.
The following table contains all the columns necessary for using each of these 3 models:
     EMPNO        MGR ENAME      LINEAGE                    NS_LOW NS_HIGH
      7839            KING       /7839/                          1      28
      7698       7839 BLAKE      /7839/7698/                     2      13
      7499       7698 ALLEN      /7839/7698/7499/                3       4
      7900       7698 JAMES      /7839/7698/7900/                5       6
      7654       7698 MARTIN     /7839/7698/7654/                7       8
      7844       7698 TURNER     /7839/7698/7844/                9      10
      7521       7698 WARD       /7839/7698/7521/               11      12
      7782       7839 CLARK      /7839/7782/                    14      17
      7934       7782 MILLER     /7839/7782/7934/               15      16
      7566       7839 JONES      /7839/7566/                    18      27
      7902       7566 FORD       /7839/7566/7902/               19      22
      7369       7902 SMITH      /7839/7566/7902/7369/          20      21
      7788       7566 SCOTT      /7839/7566/7788/               23      26
      7876       7788 ADAMS      /7839/7566/7788/7876/          24      25
The Lineage Model keeps track of all of a given nodes ancestors, so if all you need to find are the primary keys of a given node, it's really trivial: it's all in the lineage column.  If you want to find more information about those ancestors, then you can do a self-join, like this:
SELECT    a.empno, a.ename, a.lineage
FROM      emp  a
JOIN      emp  d   ON  d.lineage  LIKE '%/' || a.empno || '/%'
WHERE     d.ename  IN ('ADAMS')
ORDER BY  d.ename
,         a.lineage
Output:
     EMPNO ENAME      LINEAGE
      7839 KING       /7839/
      7566 JONES      /7839/7566/
      7788 SCOTT      /7839/7566/7788/
      7876 ADAMS      /7839/7566/7788/7876/
The Nested Sets model is harder to understand.
Imagine everyone in the hierarchy standing on a wide staircase, as if for a group picture; everyone on the same level standing on the same step.  Everyone is holding up an umbrella that is wide enough to cover himself and all the people who are under him in the hierarchy.  The people with no underlings have small umbrellas, denoted like this "<-SMITH->", and peole that manage others have bigger umbrellas, like this: <-------- JONES -------->.  So the group picture might look like this:
<-------------------------------------------- KING --------------------------------------------->
  <---------------------- BLAKE --------------------->  <-- CLARK -->  <-------- JONES -------->
   <-ALLEN-> <-JAMES-> <-MARTIN-> <-TURNER-> <-WARD->    <-MILLER->     <-- FORD--> <--SCOTT-->
                                                                         <-SMITH->   <-ADAMS->
Each parent's umbrella covers all of his descendants (children, grandchildren, etc.), and nobody else.
Now draw vertical lines trom the edges of each umbrella downwards, and number those lines from left to right:
<-------------------------------------------- KING ------------------------------------------------>
|                                                                                                  |
| <---------------------- BLAKE --------------------->  <-- CLARK ->   <-------- JONES ----------> |
| |                                                  |  |          |   |                         | |
| |<-ALLEN-> <-JAMES-> <-MARTIN-> <-TURNER-> <-WARD->|  |<-MILLER->|   |<-- FORD--> <--SCOTT---> | |
| ||       | |       | |        | |        | |      ||  ||        ||   ||         | |          | | |
| ||       | |       | |        | |        | |      ||  ||        ||   ||<-SMITH->| |<-ADAMS-> | | |
| ||       | |       | |        | |        | |      ||  ||        ||   |||       || ||       | | | |
                                           1 1      11  11        11   112       22 22       2 2 2 2
1 23       4 5       6 7        8 9        0 1      23  45        67   890       12 34       5 6 7 8
The numbers corresponding to the left arnd right edges of each umbrella are what I called ns_low and ns_high in the table.  Each employyes ns_low and ns_high numbers will be inside the range of each of his ancestors ns_low and ns_high.
To find the ancestors of a given node in the nested set model you can do this:
SELECT   a.empno, a.ename, a.ns_low, a.ns_high
FROM   emp  a
JOIN      emp  d  ON  d.ns_low  BETWEEN  a.ns_low
                                AND      a.ns_high
WHERE     d.ename  IN ('ADAMS')
ORDER BY  d.ename
,         a.ns_low
Both the Lineage and Nested Sets models are good for tree structures only, whereas the Adjacency Model can handle other kinds of graphs, including graphs with loops.
Both the Lineage and Nested Sets models can be very difficult to maintain if the hierarchy is re-organized.
I'd like to repeat some of the warnings that others have made.  You could write separate code for each system (Oracle, SQL Server, ...) that you want to run in, and the code for each system will be more or less different.  You're looking for some code that will get the same results in all systems.  That code will be more complicated that the most complicated of the single-system versions, and it will be sloweer than the slwoest of the single-system versions.  You're giving up a lot of functionality, and probably also ease of maintenance, by writing code that has to work on multiple systems without changes.
Here's how I created the emp table shown above from scott.emp:
CREATE TABLE    emp
AS
WITH    connect_by_results  AS
    SELECT  empno, mgr, ename
    ,       LEVEL   AS lvl
    ,       ROWNUM  AS r_num
    ,       SYS_CONNECT_BY_PATH (empno, '/') || '/'   AS lineage
    FROM scott.emp
    START WITH mgr IS NULL
    CONNECT BY mgr = PRIOR empno
    ORDER SIBLINGS BY ename
SELECT empno, mgr, ename, lineage
,       (2 * r_num) - lvl            AS ns_low
,       (2 * r_num) + ( 2 * (
                                SELECT  COUNT (*)
                                FROM    connect_by_results
                                WHERE   lineage  LIKE '%/' || cbr.empno || '/%'
                    - (lvl + 1)      AS ns_high
FROM connect_by_results   cbr
This relies on the fact that the hierarchy in scott.emp has only one root (that is, a node with no parent).  Computing the Nested Sets numbers is a little more complicated if you can have multiple roots.